Director

Open Match Director Edgegap's tutorial (basic)#

The Director component of Open Match is the orchestrator of everything. This component requests game proposals and assigns a game server to them.

Prerequisites#

Go
C# (HTTP)

Install Golang 1.16^ on your computer

Match Function tutorial

Create Your project#

Go
C# (HTTP)

Every Open Match service should be in its own project. Create a new folder named director for the OpenMatch director component.

In this folder, run the following command.

go mod init director

And create a file named main.go where the core logic of the component will be.

Create the main loop#

Go
C# (HTTP)

The first thing that we need for our Director is a loop that will match players every 5 seconds.

Now, in your main.go file, you can add the following code. This task will create the main loop.

main.go (Override All)

package main

import (
    "fmt"
    "time"
)

const (
    openMatchMatchFunctionHost = "basics-match-function"
    openMatchMatchFunctionPort = 50502
    openMatchBackendService    = "open-match-backend:50505" 
    // Game server data
    gameServerPort = "<APP_PORT>"      // Port Name (Port number if you port is not named) | E.G. 25565
    appName        = "<APP_NAME>"      // E.G. MySuperGame
    appVersion     = "<APP_VERSION>"   // E.G. V1
    arbitriumAPI   = "<ARBITRIUM_API>" // E.G. https://staging-api.edgegap.com/
    apiToken       = "<API_TOKEN>"     // E.G. 1111aa11aa11111a1aa11111d111a111111111a1
)

func main() {
    fmt.Println("Stating Edgegap tutorial's Director!")

    for range time.Tick(time.Second * 5) {

        fmt.Println("Creating matches...")
    }
}

You can try it by starting your app with go run ./main.go. Every 5 seconds, you should see

Creating matches...

The first thing that we need for our director is a loop that will match players every 5 seconds.

Let's update our main function. It should look like this.

Program.cs (Override All)

using director;

Director.Start();

Now, we will create a file Core.cs. This file will contain all the classes for our director component.

In Core.cs, let's create a class named Constant. In this class, we will store all the constants for our director.

In Core.cs, let's create a class named Director with a function Start.

Core.cs (Override All)

using System.Net.Http.Json;
using System.Text;
using System.Text.Json;
using Microsoft.Extensions.Logging;

namespace director
{
    public static class Constant
    {
       public const string OpenMatchMatchFunctionHost = "basics-match-function";
        public const int OpenMatchMatchFunctionPort = 51502;
        public const string OpenMatchBackendService = "open-match-backend:51505";
        // Game server data
        public const string GameServerPort = "<APP_PORT>";         // Port Name (Port number if you port is not named) | E.G. 25565 
        public const string AppName = "<APP_NAME>";                // E.G. MySuperGame 
        public const string AppVersion = "<APP_VERSION>";          // E.G. V1
        // You MUST have a forward slash (/) at the end of your URL
        public const string ArbitriumAPI = "<ARBITRIUM_API>";      // E.G. https://api.edgegap.com/
        // You MUST NOT have prefix "token" in your API token value
        // token 08230a25-0fdb-4f56-917b-0a58ec35cbaf INVALID
        // 08230a25-0fdb-4f56-917b-0a58ec35cbaf VALID
        public const string ApiToken = "<API_TOKEN>";              // E.G. 08230a25-0fdb-4f56-917b-0a58ec35cbaf
        // This tag will be associated with your deployemnt.
        // You can change it for anything you want!
        public const string DeploymentTag = "Open Match Tutorial"; // E.G. Open Match Tutorial
    }

    public static class Director
    {
        private static readonly ILogger logger = LoggerFactory.Create(
            logBuilder => logBuilder.AddConsole(
                configuration =>
                {
                    configuration.TimestampFormat = "[HH:mm:ss] ";
                })
            ).CreateLogger("Director");

        public static void Start()
        {
            while (true)
            {
                logger.LogInformation("Creating matches...");
                MatchPlayers();
                Thread.Sleep(5000);
            }
        }

        private static async Task MatchPlayers()
        {
        }
    }
}

Don't forget to change the variables gameServerPort, appName, appVersion, arbitriumAPI, apiToken with valid data. The values should come from Arbitrium. It should be an application that you own.

Get Profiles#

Go
C# (HTTP)

In order to obtain match proposals, we will need profiles. We will create a method that returns a list of profiles. We will need Open Match dependency for that.

go get open-match.dev/open-match/pkg/pb

Here is the code for profiles generation

main.go (Add to file)

// Get all the possible profiles
func getProfiles() []*pb.MatchProfile {
    var profiles []*pb.MatchProfile
    modes := []string{"mode.casual", "mode.ranked", "mode.private"}
    for _, mode := range modes {
        profiles = append(profiles, &pb.MatchProfile{
            Name: fmt.Sprintf("%s_profile", mode),
            Pools: []*pb.Pool{
                {
                    Name: "pool_" + mode,
                    TagPresentFilters: []*pb.TagPresentFilter{
                        {
                            Tag: mode,
                        },
                    },
                },
            },
        },
        )
    }

    return profiles
}

You will have to change your dependencies. They should look like this

main.go (Replace)

import (
    "fmt"
    "time"

    "open-match.dev/open-match/pkg/pb"
)

In order to obtain match proposals, we will need profiles. We will create a method that returns a list of profiles.

Now, we will create a file named Models.cs. This file will contain all the models.

Models.cs (Override All)

using System.Net.Http.Json;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;

namespace director
{
    // Based On OpenMatchMatchProfile in https://open-match.dev/site/swaggerui/index.html?urls.primaryName=Backend
    public struct OpenMatchMatchProfile
    {
        [JsonPropertyName("name")]
        public string Name { get; set; }
        [JsonPropertyName("pools")]
        public OpenMatchPool[] Pools { get; set; }
        [JsonPropertyName("extensions")]
        public Dictionary<string, ProtobufAny> Extensions { get; set; }
    }

    // Based On ProtobufAny in https://open-match.dev/site/swaggerui/index.html?urls.primaryName=Backend
    public struct OpenMatchPool
    {
        [JsonPropertyName("name")]
        public string Name { get; set; }
        [JsonPropertyName("tag_present_filters")]
        public TagPresentFilter[] TagPresentFilters { get; set; }
    }

    // Based On TagPresentFilter in https://open-match.dev/site/swaggerui/index.html?urls.primaryName=Backend
    public struct TagPresentFilter
    {
        [JsonPropertyName("tag")]
        public string Tag { get; set; }
    }

    // Based On ProtobufAny in https://open-match.dev/site/swaggerui/index.html?urls.primaryName=Backend
    public struct ProtobufAny
    {
        [JsonPropertyName("@type")]
        public string TypeUrl { get; set; }
        [JsonPropertyName("value")]
        public byte[] Value { get; set; }
    }
}

Let's add a function to get all the profiles in our Director class.

Core.cs (Add to Director class)

/// <summary>
/// Get all the possible profiles
/// </summary>
private static IEnumerable<OpenMatchMatchProfile> GetProfiles()
{
    string[] modes = new string[] { "mode.casual", "mode.ranked", "mode.private" };

    foreach (string mode in modes)
    {
        yield return new OpenMatchMatchProfile
        {
            Name = $"{mode}_profile",
            Pools = new OpenMatchPool[]
            {
                new OpenMatchPool
                {
                    Name = $"pool_{mode}",
                    TagPresentFilters = new TagPresentFilter[] { new TagPresentFilter {  Tag = mode } }
                }
            }
        };
    }
}

Create a connection to Open Match Backend service#

Go
C# (HTTP)

We will retrieve the match proposals by communicating to Open Match Backend service via gRPC. We need to create the connection.

For that, we need gRPC dependency

go get google.golang.org/grpc

Here is the code that creates the connection.

main.go (Add to file)

// Create a connection to Open Match Backend service
func newBackendConnection() pb.BackendServiceClient {
    conn, err := grpc.Dial(
        openMatchBackendService, grpc.WithInsecure(),
    )

    if err != nil {
        log.Printf("Error while communicating with Open Match Backend, err: %v", err.Error())
    }

    return pb.NewBackendServiceClient(conn)
}

You will have to change your dependencies. They should look like this

main.go (Replace)

import (
    "fmt"
    "time"
    "log"

    "google.golang.org/grpc"
    "open-match.dev/open-match/pkg/pb"
)

Fetching match proposals#

Go
C# (HTTP)

The next step would be to create a function that will fetch the match proposals for a specific profile. We will make a call to Open Match Back End service.

Here is the piece of code for that.

main.go (Add to file)

// fetch Fetch profile's matches
func fetch(p *pb.MatchProfile, backendService pb.BackendServiceClient) ([]*pb.Match, error) {
    // Making request object
    req := &pb.FetchMatchesRequest{
        Config: &pb.FunctionConfig{
            Host: openMatchMatchFunctionHost,
            Port: openMatchMatchFunctionPort,
            Type: pb.FunctionConfig_GRPC,
        },
        Profile: p,
    }

    // Getting match proposals
    stream, err := backendService.FetchMatches(context.Background(), req)
    if err != nil {
        return nil, err
    }

    var result []*pb.Match
    for {
        resp, err := stream.Recv()
        if err == io.EOF {
            break
        }

        if err != nil {
            return nil, err
        }

        result = append(result, resp.GetMatch())
    }

    return result, nil
}

You will have to change your dependencies. They should look like this

main.go (Replace)

import (
    "fmt"
    "time"
    "log"
    "io"
    "context"

    "google.golang.org/grpc"
    "open-match.dev/open-match/pkg/pb"
)

The next step would be to create a function that will fetch the match proposals for a specific profile. We will make a call to Open Match Back End service.

Here is the piece of code for that. Let's add it to our Director class

Core.cs (Add to Director class)

/// <summary>
/// Fetch profile's matches
/// </summary>
private static async Task<IList<OpenMatchMatch>> Fetch(OpenMatchMatchProfile profile)
{
    HttpClient client = new HttpClient();

    // Making request object
    var body = new
    {
        config = new MMFConfig
        {
            Host = Constant.OpenMatchMatchFunctionHost,
            Port = Constant.OpenMatchMatchFunctionPort,
            Type = "REST",
        },
        profile = profile

    };

    List<OpenMatchMatch> proposals = new List<OpenMatchMatch>();

    // Getting match proposals
    try
    {
        // Sending the request to Open Match Backend
        HttpResponseMessage response = await client.PostAsJsonAsync(
            $"http://{Constant.OpenMatchBackendService}/v1/backendservice/matches:fetch",
            body
        );

        string stringBody = await response.Content.ReadAsStringAsync();
        IEnumerable<string> results = stringBody.Trim().Split('\n').Where(s => s is not null && s.Trim() != "");

        if (response.StatusCode != System.Net.HttpStatusCode.OK)
        {
            throw new Exception($"Resquest Error {(int)response.StatusCode} - {stringBody}");
        }

        // Extracting propsals from response
        foreach (string result in results)
        {
            var matchResult = JsonSerializer.Deserialize<OpenMatchStreamResult<OpenMatchFetchMatchesResponse>>(result);
            proposals.Add(matchResult.Result.Match);
        }
    }
    catch (Exception ex)
    {
        throw new Exception($"Failed to fetch matches for profile {profile.Name}, got {ex.Message}", ex);
    }

    return proposals;
}

You will have to update Model.cs.

Model.cs (Add to namespace director)

// Based On MMFConfig in https://open-match.dev/site/swaggerui/index.html?urls.primaryName=Backend
public struct MMFConfig
{
    [JsonPropertyName("host")]
    public string Host { get; set; }
    [JsonPropertyName("port")]
    public int Port { get; set; }
    [JsonPropertyName("type")]
    public string Type { get; set; }
}

// Based On Stream result in https://open-match.dev/site/swaggerui/index.html?urls.primaryName=Backend
public struct OpenMatchStreamResult<T>
{
    [JsonPropertyName("result")]
    public T Result { get; set; }
}

// Based On OpenMatchFetchMatchesResponse in https://open-match.dev/site/swaggerui/index.html?urls.primaryName=Backend
public struct OpenMatchFetchMatchesResponse
{
    [JsonPropertyName("match")]
    public OpenMatchMatch Match { get; set; }
}

// Based On OpenMatchMatch in https://open-match.dev/site/swaggerui/index.html?urls.primaryName=Backend
public struct OpenMatchMatch
{
    [JsonPropertyName("match_id")]
    public string MatchId { get; set; }
    [JsonPropertyName("match_profile")]
    public string MatchProfile { get; set; }
    [JsonPropertyName("match_function")]
    public string MatchFunction { get; set; }
    [JsonPropertyName("tickets")]
    public OpenMatchTicket[] Tickets { get; set; }
}

// Based On OpenMatchTicket in https://open-match.dev/site/swaggerui/index.html?urls.primaryName=Frontend
public struct OpenMatchTicket
{
    [JsonPropertyName("id")]
    public string Id { get; set; }
    [JsonPropertyName("search_fields")]
    public OpenMatchSearchFields SearchFields { get; set; }
    [JsonPropertyName("extensions")]
    public Dictionary<string, ProtobufAny> Extensions { get; set; }
}

// Based On OpenMatchSearchFields in https://open-match.dev/site/swaggerui/index.html?urls.primaryName=Frontend
public struct OpenMatchSearchFields
{
    [JsonPropertyName("tags")]
    public string[] Tags { get; set; }
}

Assign game server to match proposals#

We need a function that will assign a game server to our match proposals. It is here that we will call Arbitrium API (CoDeMa).

Using Arbitrium deployment#

This section shows you how to integrate Arbitrium's deployment into your Director. If you use Arbitrium's session, you should go to the next section.

Info :

We assume that you already experimented with Arbitrium's deployment and know how they work. If you don't, we recommend you to see this section

Go
C# (HTTP)

You could make an HTTP request by following our API call definitions; however, we will use an auto-generated Go SDK. You can learn how to generate an SDK here. In your director project, you will have to create a swagger folder and put the generated SDK inside.

main.go (Add to file)

// assign Deploy a game server with CoDeMa API and assign its IP to match's tickets
func assign(matches []*pb.Match, backendService pb.BackendServiceClient) error {
    for _, match := range matches {
        // Getting Tickets ID and players IP
        ticketIDs := []string{}
        IPS := []string{}
        for _, t := range match.GetTickets() {
            ticketIDs = append(ticketIDs, t.Id)
            IPS = append(IPS, string(t.Extensions["playerIp"].Value))
        }

        // Game server port
        gamePort := gameServerPort

        // Deploying game server and getting ip
        conn, err := getServerIP(IPS, gamePort)

        if err != nil {
            return fmt.Errorf("AssignTickets failed for match %v, got %w", match.GetMatchId(), err)
        }

        // Assign game server to tickets
        req := &pb.AssignTicketsRequest{
            Assignments: []*pb.AssignmentGroup{
                {
                    TicketIds: ticketIDs,
                    Assignment: &pb.Assignment{
                        Connection: conn,
                    },
                },
            },
        }

        if _, err := backendService.AssignTickets(context.Background(), req); err != nil {
            return fmt.Errorf("AssignTickets failed for match %v, got %w", match.GetMatchId(), err)
        }

        log.Printf("Assigned server %v to match %v", conn, match.GetMatchId())
    }

    return nil
}

// getServerIP Deploy the Game server and fetch its IP when the server is ready
func getServerIP(ips []string, gamePort string) (string, error) {
    // Creating Arbitrium deploy request
    payload := swagger.DeployModel{
        AppName:     appName,
        VersionName: appVersion,
        IpList:      ips,
    }

    // Creating API Client to communicate with arbitrium
    configuration := swagger.NewConfiguration()
    configuration.BasePath = arbitriumAPI
    client := swagger.NewAPIClient(configuration)
    auth := context.WithValue(context.Background(), swagger.ContextAPIKey, swagger.APIKey{
        Key:    apiToken,
        Prefix: "token",
    })

    // Deploying
    request, _, err := client.DeploymentsApi.Deploy(auth, payload)

    if err != nil {
        log.Printf("Could not deploy game server, err: %v", err.Error())
        return "", err
    }

    timeout := 30.0
    start := time.Now()

    status := ""
    var response swagger.Status

    // Waiting for the server to be ready
    for status != "Status.READY" && time.Since(start).Seconds() <= timeout {
        response, _, err = client.DeploymentsApi.DeploymentStatusGet(auth, request.RequestId)

        if err != nil {
            log.Printf("Error while fetching status, err: %v", err.Error())
        }

        status = response.CurrentStatus
        time.Sleep(1 * time.Second) //  let's wait a bit
    }

    if time.Since(start).Seconds() > timeout {
        return "", errors.New("Timeout while waiting for deployment")
    }

    return fmt.Sprintf("%s:%d", response.PublicIp, response.Ports[gamePort].External), nil
}

You will have to change your dependencies. They should look like this

main.go (Replace)

import (
    "fmt"
    "time"
    "log"
    "io"
    "context"
    "errors"
    "director/swagger" 

    "google.golang.org/grpc"
    "open-match.dev/open-match/pkg/pb"
)

Core.cs (Add to Director class)

/// <summary>
/// Deploy a game server with CoDeMa API and assign its IP to match's tickets
/// </summary>
private static async Task Assign(IEnumerable<OpenMatchMatch> matches)
{
    foreach (OpenMatchMatch match in matches)
    {
        // Getting Tickets ID and players IP
        string[] ticketsId = match.Tickets.Select(t => t.Id).ToArray();
        string[] ipList = match.Tickets.Select(t => Encoding.UTF8.GetString(t.Extensions["playerIp"].Value)).ToArray();

        // Deploying game server and getting ip
        string ip = await GetServerIP(ipList, Constant.GameServerPort);

        // Assign game server to tickets
        try
        {
            HttpClient client = new HttpClient();

            OpenMatchAssignTicketsRequest body = new OpenMatchAssignTicketsRequest
            {
                Assignments = new OpenMatchAssignmentGroup[]
                {
                    new OpenMatchAssignmentGroup
                    {
                        TicketIds = ticketsId,
                        Assignment = new OpenMatchAssignment{ Connection = ip },
                    }
                }
            };

            // Sending the request to Open Match Backend
            HttpResponseMessage response = await client.PostAsJsonAsync(
                $"http://{Constant.OpenMatchBackendService}/v1/backendservice/tickets:assign",
                body
            );

            if (response.StatusCode != System.Net.HttpStatusCode.OK)
            {
                throw new Exception($"Resquest Error {(int)response.StatusCode} - {await response.Content.ReadAsStringAsync()}");
            }
        }
        catch (Exception ex)
        {
            throw new Exception($"Could not assign ticket", ex);
        }

        logger.LogInformation($"Assigned server {ip} to match {match.MatchId}");
    }
}

/// <summary>
/// Deploy the Game server and fetch its IP when the server is ready
/// </summary>
private static async Task<string> GetServerIP(string[] IPList, string gamePort)
{
    // Creating API Client to communicate with arbitrium
    HttpClient client = new HttpClient();
    // Add authorization
    client.DefaultRequestHeaders.Add("authorization", $"token {Constant.ApiToken}");

    string requestId;

    try
    {
        // Creating Arbitrium deploy request
        // Based on https://docs.edgegap.com/api/#operation/deploy
        var body = new
        {
            app_name = Constant.AppName,
            version_name = Constant.AppVersion,
            ip_list = IPList,
            tags = new string[] { Constant.DeploymentTag }
        };


        // Deploying
        // Sending the request to Arbitrium
        HttpResponseMessage response = await client.PostAsJsonAsync(
            $"{Constant.ArbitriumAPI}v1/deploy",
            body
        );

        if (response.StatusCode != System.Net.HttpStatusCode.OK)
        {
            throw new Exception($"Resquest Error {(int)response.StatusCode} - {await response.Content.ReadAsStringAsync()}");
        }

        requestId = (await response.Content.ReadFromJsonAsync<ArbitriumDeployResponse>()).RequestId;
    }
    catch (Exception ex)
    {
        throw new Exception($"ERROR: Could not deploy game server, err: {ex.Message}", ex);
    }

    double timeout = 30.0;
    DateTime start = DateTime.UtcNow;

    string? status = "";
    ArbitriumDeploymentRequestStatusResponse responseBody = new();

    // Waiting for the server to be ready
    while (status != "Status.READY" && (DateTime.UtcNow - start).TotalSeconds <= timeout)
    {
        try
        {
            // Based on https://develop-docs.edgegap.com/api/#operation/deployment-status-get
            // Sending the request to Arbitrium
            HttpResponseMessage response = await client.GetAsync($"{Constant.ArbitriumAPI}v1/status/{requestId}");

            if (response.StatusCode != System.Net.HttpStatusCode.OK)
            {
                throw new Exception($"Resquest Error {(int)response.StatusCode} - {await response.Content.ReadAsStringAsync()}");
            }

            responseBody = await response.Content.ReadFromJsonAsync<ArbitriumDeploymentRequestStatusResponse>();
            status = responseBody.CurrentStatus;
            await Task.Delay(1000); //  let's wait a bit
        }
        catch (Exception ex)
        {
            throw new Exception($"ERROR: Could not fetch status, err: {ex.Message}", ex);
        }
    }

    if ((DateTime.UtcNow - start).TotalSeconds > timeout)
    {
        throw new Exception($"ERROR: Timeout while waiting for deployment");
    }

    return $"{responseBody.PublicIP}:{responseBody.Ports[Constant.GameServerPort].External}";
}

You will have to update Model.cs.

Model.cs (Add to namespace match_function)

// Based on https://docs.edgegap.com/api/#operation/deploy
public struct ArbitriumDeployResponse
{
    [JsonPropertyName("request_id")]
    public string RequestId { get; set; }
}

// Based on https://docs.edgegap.com/api/#operation/deployment-status-get
public struct ArbitriumDeploymentRequestStatusResponse
{
    [JsonPropertyName("current_status")]
    public string CurrentStatus { get; set; }
    [JsonPropertyName("public_ip")]
    public string PublicIP { get; set; }
    [JsonPropertyName("ports")]
    public Dictionary<string, DeploymentPort> Ports { get; set; }

}

// Based on https://docs.edgegap.com/api/#operation/deployment-status-get
public struct DeploymentPort
{
    [JsonPropertyName("external")]
    public int External { get; set; }
    [JsonPropertyName("internal")]
    public int Internal { get; set; }
    [JsonPropertyName("protocol")]
    public string Protocol { get; set; }
}

// Based on OpenMatchAssignTicketsRequest https://open-match.dev/site/swaggerui/index.html?urls.primaryName=Backend
public struct OpenMatchAssignTicketsRequest
{
    [JsonPropertyName("assignments")]
    public OpenMatchAssignmentGroup[] Assignments { get; set; }
}

// Based on OpenMatchAssignmentGroup https://open-match.dev/site/swaggerui/index.html?urls.primaryName=Backend
public struct OpenMatchAssignmentGroup
{
    [JsonPropertyName("ticket_ids")]
    public string[] TicketIds { get; set; }
    [JsonPropertyName("assignment")]
    public OpenMatchAssignment Assignment { get; set; }
}

// Based on OpenMatchAssignment https://open-match.dev/site/swaggerui/index.html?urls.primaryName=Backend
public struct OpenMatchAssignment
{
    [JsonPropertyName("connection")]
    public string Connection { get; set; }
}

Using Arbitrium session#

This section shows you how to integrate Arbitrium's session into your Director. If you use Arbitrium's deployment, you should go to the previous section.

Info :

We assume that you already experimented with Arbitrium's deployment and know how they work. If you don't, we recommend you to see this section

Warning :

If your App Version (session kind) IS NOT in auto-deploy, you will need an instance running to link your session.

If your App Version (session kind) IS in auto-deploy, it will deploy a server automatically. It could end up in multiple instances running.

Go
C# (HTTP)

main.go (Add to file)

// assign Deploy a game server with CoDeMa API and assign its IP to match's tickets
func assign(matches []*pb.Match, backendService pb.BackendServiceClient) error {
    for _, match := range matches {
        // Getting Tickets ID and players IP
        ticketIDs := []string{}
        IPS := []string{}
        for _, t := range match.GetTickets() {
            ticketIDs = append(ticketIDs, t.Id)
            IPS = append(IPS, string(t.Extensions["playerIp"].Value))
        }

        // Game server port
        gamePort := gameServerPort

        // Deploying game server and getting ip
        conn, err := getServerIP(IPS, gamePort)

        if err != nil {
            return fmt.Errorf("AssignTickets failed for match %v, got %w", match.GetMatchId(), err)
        }

        // Assign game server to tickets
        req := &pb.AssignTicketsRequest{
            Assignments: []*pb.AssignmentGroup{
                {
                    TicketIds: ticketIDs,
                    Assignment: &pb.Assignment{
                        Connection: conn,
                    },
                },
            },
        }

        if _, err := backendService.AssignTickets(context.Background(), req); err != nil {
            return fmt.Errorf("AssignTickets failed for match %v, got %w", match.GetMatchId(), err)
        }

        log.Printf("Assigned server %v to match %v", conn, match.GetMatchId())
    }

    return nil
}

// getServerIP Deploy the Game server and fetch its IP when the server is ready
func getServerIP(ips []string, gamePort string) (string, error) {
    // Creating Arbitrium deploy request
    payload := swagger.SessionModel{
        AppName:     appName,
        VersionName: appVersion,
        IpList:      ips,
    }

    // Creating API Client to communicate with arbitrium
    configuration := swagger.NewConfiguration()
    configuration.BasePath = arbitriumAPI
    client := swagger.NewAPIClient(configuration)
    auth := context.WithValue(context.Background(), swagger.ContextAPIKey, swagger.APIKey{
        Key:    apiToken,
        Prefix: "token",
    })

    // Deploying
    request, _, err := client.SessionsApi.SessionPost(auth, payload)

    if err != nil {
        log.Printf("Could not deploy game server, err: %v", err.Error())
        return "", err
    }

    timeout := 30.0
    start := time.Now()

    ready := false
    var response swagger.SessionGet

    // Waiting for the server to be ready
    for !ready && time.Since(start).Seconds() <= timeout {
        response, _, err = client.SessionsApi.GetSession(auth, request.SessionId)

        if err != nil {
            log.Printf("Error while fetching status, err: %v", err.Error())
        }

        ready = response.Ready
        time.Sleep(1 * time.Second) //  let's wait a bit
    }

    if time.Since(start).Seconds() > timeout {
        return "", errors.New("Timeout while waiting for deployment")
    }

    return fmt.Sprintf("%s:%d", response.Deployment.PublicIp, response.Deployment.Ports[gamePort].External), nil
}

You will have to change your dependencies. They should look like this

main.go (Replace)

import (
    "fmt"
    "time"
    "log"
    "io"
    "context"
    "errors"
    "director/swagger" 

    "google.golang.org/grpc"
    "open-match.dev/open-match/pkg/pb"
)

Putting everything together#

Go
C# (HTTP)

Now it's time to put all the pieces together. Our main function should look like this.

main.go (Replace)

func main() {
    fmt.Println("Stating Edgegap tutorial's Director!")

    backendService := newBackendConnection()

    for range time.Tick(time.Second * 5) {
        fmt.Println("Creating matches...")

        var wg sync.WaitGroup
        for _, p := range getProfiles() {
            wg.Add(1)
            go func(wg *sync.WaitGroup, profile *pb.MatchProfile) {
                defer wg.Done()

                matches, err := fetch(profile, backendService)

                if err != nil {
                    log.Printf("Failed to fetch matches for profile %v, got %s", profile.GetName(), err.Error())
                    return
                }

                log.Printf("Generated %v matches for profile %v", len(matches), profile.GetName())

                if err := assign(matches, backendService); err != nil {
                    log.Printf("Failed to assign servers to matches, got %s", err.Error())
                    return
                }
            }(&wg, p)
        }
        wg.Wait()
    }
}

You will have to change your dependencies. They should look like this

main.go (Replace)

import (
    "fmt"
    "time"
    "log"
    "io"
    "context"
    "errors"
    "sync"
    "director/swagger" 

    "google.golang.org/grpc"
    "open-match.dev/open-match/pkg/pb"
)

It will be hard to test this service in a standalone context. We will see it in action when all the services (Front end, Director, and Match Function) will be ready.

Containerize your service#

Go
C# (HTTP)

Containerization is powerful. You can learn more about it on Edgegap's documentation or Docker. Our container, we will use golang:1.16 for its base image.

Create a file named Dockerfile and write this inside.

FROM golang:1.16

COPY . /go/src/app
WORKDIR /go/src/app

RUN go get -d -v /go/src/app
RUN go install -v /go/src/app

WORKDIR /go/bin 

CMD ["director"]

You can now build your image using.

docker build -t edgegap-om-tuto-director:tuto .

You can run it using this command, but without all the other services, it will not work.

docker run -it --name om-tuto-director edgegap-om-tuto-director:tuto

Conclusion#

You now have a basic Open Match Director service. This is not production-ready. However, you will learn the key function of Open Match Director. You also created a Docker image that can be used later.

Warning : The code in this tutorial is only an introduction. Unfortunately, there’s no mechanism to clean your deployments. If they do not deploy correctly, the tickets won’t be assigned. In the next loop, the Director will try to deploy a new server.