public void MatchASinglePlayerParty()
{
// Create a solo party.
_partyClient.CreateParty(new CreatePartyRequest(), _leaderMetadata);
// Join matchmaking.
_gatewayClient.Join(new JoinRequest
{
MatchmakingType = "match1"
}, _leaderMetadata);
// Verify that the solo-party has been successfully matched to a deployment.
AssertWithinSeconds(10, () =>
{
var op = _operationsClient.GetOperation(LeaderPlayerId,
CallSettings.FromHeader(PitRequestHeaderName, _leaderPit));
if (!op.Done)
{
return(false);
}
var assignment = op.Response.Unpack <JoinResponse>();
return(assignment.DeploymentName.Equals("test_deployment_1") &&
!string.IsNullOrEmpty(assignment.LoginToken));
});
// Clean-up.
_partyClient.DeleteParty(new DeletePartyRequest(), _leaderMetadata);
}
public void AllowAJoinRequestToBeDeleted()
{
// Create a solo party.
_partyClient.CreateParty(new CreatePartyRequest(), _leaderMetadata);
// Join matchmaking.
var op = _gatewayClient.Join(new JoinRequest
{
MatchmakingType = "no_match"
}, _leaderMetadata);
Assert.AreEqual(LeaderPlayerId, op.Name);
Assert.False(op.Done);
// Verify that the party has not been matched yet.
var fetchedOp = _operationsClient.GetOperation(LeaderPlayerId,
CallSettings.FromHeader(PitRequestHeaderName, _leaderPit));
Assert.AreEqual(LeaderPlayerId, fetchedOp.Name);
Assert.False(fetchedOp.Done);
// Cancel matchmaking.
_operationsClient.DeleteOperation(LeaderPlayerId,
CallSettings.FromHeader(PitRequestHeaderName, _leaderPit));
// Verify that there is no more information within the matchmaking system about the party/player.
var rpcException = Assert.Throws <RpcException>(() =>
_operationsClient.GetOperation(LeaderPlayerId,
CallSettings.FromHeader(PitRequestHeaderName, _leaderPit)));
Assert.AreEqual(StatusCode.NotFound, rpcException.Status.StatusCode);
// Clean-up.
_partyClient.DeleteParty(new DeletePartyRequest(), _leaderMetadata);
}
private async Task <StreamingRecognizeStream> GetGoogleStream(int SampleRate)
{
var sslCredentials = new SslCredentials();
var speechBuilder = new SpeechClientBuilder();
speechBuilder.ChannelCredentials = sslCredentials;
//speechBuilder.Endpoint = "google.com/speech-api/";
var speech = speechBuilder.Build();
var streamingCall = speech.StreamingRecognize(CallSettings.FromHeader("x-goog-api-key", ApiKey));
// Write the initial request with the config.
await streamingCall.WriteAsync(
new StreamingRecognizeRequest()
{
StreamingConfig = new StreamingRecognitionConfig()
{
Config = new RecognitionConfig()
{
Encoding = RecognitionConfig.Types.AudioEncoding.Linear16,
SampleRateHertz = SampleRate,
LanguageCode = CultureLanguage.ToString(),
EnableAutomaticPunctuation = false,
AudioChannelCount = 1,
UseEnhanced = true
},
InterimResults = false,
}
});
return(streamingCall);
}
public void PreventPartiesFromQueueingTwice()
{
// Create a solo party.
_partyClient.CreateParty(new CreatePartyRequest(), _leaderMetadata);
// Join matchmaking.
_gatewayClient.Join(new JoinRequest
{
MatchmakingType = "no_match"
}, _leaderMetadata);
// Verify that en exception is thrown if trying to join matchmaking again.
var rpcException = Assert.Throws <RpcException>(() => _gatewayClient.Join(new JoinRequest
{
MatchmakingType = "no_match"
}, _leaderMetadata));
Assert.AreEqual(StatusCode.AlreadyExists, rpcException.Status.StatusCode);
Assert.That(rpcException.Message, Contains.Substring("already queued"));
// Clean-up.
_operationsClient.DeleteOperation(LeaderPlayerId,
CallSettings.FromHeader(PitRequestHeaderName, _leaderPit));
_partyClient.DeleteParty(new DeletePartyRequest(), _leaderMetadata);
}
public void WithEarlierDeadline_SimpleSettingsNoDeadline()
{
CallSettings settings = CallSettings.FromHeader("name", "value");
DateTime? deadline = null;
Assert.Same(settings, settings.WithEarlierDeadline(deadline, new FakeClock()));
}
public void FromHeader()
{
var settings = CallSettings.FromHeader("name", "value");
var metadata = new Metadata();
settings.HeaderMutation(metadata);
Assert.Equal("name", metadata[0].Key);
Assert.Equal("value", metadata[0].Value);
}
public void MatchAMultiPlayerParty()
{
// Create a party with multiple players within it.
var partyId =
_partyClient.CreateParty(new CreatePartyRequest(), _leaderMetadata)
.PartyId;
var pitAnotherMember = CreatePlayerIdentityTokenForPlayer(MemberPlayerId);
var inviteAnotherPlayer = _inviteClient.CreateInvite(new CreateInviteRequest {
ReceiverPlayerId = MemberPlayerId
},
_leaderMetadata).InviteId;
Assert.NotNull(inviteAnotherPlayer);
_partyClient.JoinParty(new JoinPartyRequest {
PartyId = partyId
},
new Metadata {
{ PitRequestHeaderName, pitAnotherMember }
});
// Join matchmaking.
_gatewayClient.Join(new JoinRequest
{
MatchmakingType = "match1"
}, _leaderMetadata);
AssertWithinSeconds(10, () =>
{
var leaderOp = _operationsClient.GetOperation(LeaderPlayerId,
CallSettings.FromHeader(PitRequestHeaderName, _leaderPit));
if (!leaderOp.Done)
{
return(false);
}
var assignment = leaderOp.Response.Unpack <JoinResponse>();
Assert.AreEqual("test_deployment_1", assignment.DeploymentName);
Assert.False(string.IsNullOrEmpty(assignment.LoginToken));
// Verify that the other member has been matched into the same deployment as the leader.
var otherMemberOp = _operationsClient.GetOperation(MemberPlayerId,
CallSettings.FromHeader(PitRequestHeaderName, CreatePlayerIdentityTokenForPlayer(MemberPlayerId)));
Assert.True(otherMemberOp.Done);
var memberAssignment = otherMemberOp.Response.Unpack <JoinResponse>();
Assert.AreEqual("test_deployment_1", memberAssignment.DeploymentName);
Assert.False(string.IsNullOrEmpty(memberAssignment.LoginToken));
return(true);
});
// Clean-up.
_partyClient.DeleteParty(new DeletePartyRequest(), _leaderMetadata);
_inviteClient.DeleteInvite(new DeleteInviteRequest {
InviteId = inviteAnotherPlayer
}, _leaderMetadata);
}
public void WithHeader_NonNullSettings()
{
CallSettings settings = CallSettings.FromHeader("name1", "value1");
var result = settings.WithHeader("name2", "value2");
var metadata = new Metadata();
result.HeaderMutation(metadata);
Assert.Equal("name1", metadata[0].Key);
Assert.Equal("value1", metadata[0].Value);
Assert.Equal("name2", metadata[1].Key);
Assert.Equal("value2", metadata[1].Value);
}
public async Task PollUntilCompletedAsync_NoHeaderDuplication_WithCallSettings(bool provideCallSettings)
{
var baseSettings = CallSettings.FromHeader("foo", "bar");
var client = new FakeOperationsClient(new FakeScheduler(), baseSettings, settings => Assert.Null(settings?.HeaderMutation));
var callSettings = provideCallSettings ? CallSettings.FromCancellationToken(new CancellationTokenSource().Token) : null;
await client.FakeScheduler.RunAsync(async() =>
{
client.AddSuccessfulOperation("op", client.Clock.GetCurrentDateTimeUtc().AddSeconds(3), new StringValue {
Value = "result"
});
var initial = Operation <StringValue, Timestamp> .PollOnceFromNameAsync("op", client).Result;
await initial.PollUntilCompletedAsync(callSettings: callSettings);
});
}
internal WatchStream(IScheduler scheduler, IWatchState state, Target target, FirestoreDb db, CancellationToken cancellationToken)
{
_scheduler = scheduler;
_state = state;
_target = target;
_db = db;
_callbackCancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
_networkCancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(_callbackCancellationTokenSource.Token);
_listenCallSettings = CallSettings.FromHeader(FirestoreClientImpl.ResourcePrefixHeader, db.RootPath);
// TODO: Make these configurable?
_backoffSettings = new BackoffSettings(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(30), 2.0);
_backoffJitter = RetrySettings.RandomJitter;
}
public void PerRpc()
{
string projectId = _fixture.ProjectId;
string topicId = _fixture.CreateTopicId();
// Sample: PerRpc
// Create a PublisherServiceApiClient with default settings.
PublisherServiceApiClient client = PublisherServiceApiClient.Create();
// Create a topic name from the projectId and topicId.
TopicName topicName = new TopicName(projectId, topicId);
// Create a CallSettings with a custom header.
CallSettings callSettings = CallSettings.FromHeader("ClientVersion", "1.0.0");
// This will cause the custom 'ClientVersion' header to be included in the RPC call.
Topic topic = client.CreateTopic(topicName, callSettings);
// End sample
}
internal WatchStream(IScheduler scheduler, IWatchState state, Target target, FirestoreDb db, CancellationToken cancellationToken)
{
_scheduler = scheduler;
_state = state;
_target = target;
_db = db;
_callbackCancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
_networkCancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(_callbackCancellationTokenSource.Token);
_listenCallSettings = CallSettings.FromHeader(FirestoreClientImpl.ResourcePrefixHeader, db.RootPath);
// TODO: Make these configurable?
_backoffSettings = RetrySettings.FromExponentialBackoff(
maxAttempts: int.MaxValue,
initialBackoff: TimeSpan.FromSeconds(1),
maxBackoff: TimeSpan.FromSeconds(30),
backoffMultiplier: 2.0,
retryFilter: _ => false, // Ignored
backoffJitter: RetrySettings.RandomJitter);
}
public void Client()
{
string projectId = _fixture.ProjectId;
string topicId = _fixture.CreateTopicId();
// Sample: ClientWide
// Create a default PublisherServiceApiSettings, with a custom header for calls to all RPC methods.
PublisherServiceApiSettings publisherSettings = new PublisherServiceApiSettings
{
CallSettings = CallSettings.FromHeader("ClientVersion", "1.0.0")
};
PublisherServiceApiClient client = new PublisherServiceApiClientBuilder {
Settings = publisherSettings
}.Build();
// Create a topic name from the projectId and topicId.
TopicName topicName = new TopicName(projectId, topicId);
// The custom 'ClientVersion' header will be included in the RPC call, due to
// the client being configured with 'publishersettings' above.
Topic topic = client.CreateTopic(topicName);
// End sample
}
public void MatchARequeuedPlayerEventually()
{
// Create a solo party.
_partyClient.CreateParty(new CreatePartyRequest(), _leaderMetadata);
// Join matchmaking.
_gatewayClient.Join(new JoinRequest
{
MatchmakingType = "to_requeue"
}, _leaderMetadata);
AssertWithinSeconds(25, () =>
{
var op = _operationsClient.GetOperation(LeaderPlayerId,
CallSettings.FromHeader(PitRequestHeaderName, _leaderPit));
if (!op.Done)
{
return(false);
}
if (op.Error != null)
{
Assert.Fail($"Op returned error code: {op.Error.Code}");
return(false);
}
var res = op.Response.Unpack <JoinResponse>();
if (res.DeploymentName.Equals("test_deployment_requeue") && !string.IsNullOrEmpty(res.LoginToken))
{
return(true);
}
Assert.Fail($"User was not matched to correct deployment. Was: {res.DeploymentName}");
return(false);
});
// Clean up.
_partyClient.DeleteParty(new DeletePartyRequest(), _leaderMetadata);
}
public void FromHeader_Invalid(string header, string value) => Assert.Throws <InvalidOperationException>(() => CallSettings.FromHeader(header, value));
public void MatchPartiesInABatch()
{
var invitesList = new List <string>();
// Create three parties with a different amount of members. The first one is a solo party, the rest have two
// and three members respectively.
var leaderIds = new List <string>();
var leaderIdToMembers = new Dictionary <string, List <string> >();
var playerPits = new Dictionary <string, string>();
for (var partyCount = 1; partyCount <= 3; partyCount++)
{
var leaderId = $"leader_{partyCount}";
var leaderPit = CreatePlayerIdentityTokenForPlayer(leaderId);
playerPits[leaderId] = leaderPit;
var partyId = _partyClient.CreateParty(new CreatePartyRequest(),
new Metadata {
{ PitRequestHeaderName, leaderPit }
}).PartyId;
for (var memberCount = 1; memberCount < partyCount; memberCount++)
{
var memberId = $"member_{partyCount}_{memberCount}";
var memberPit = CreatePlayerIdentityTokenForPlayer(memberId);
var inviteAnotherPlayer = _inviteClient.CreateInvite(new CreateInviteRequest {
ReceiverPlayerId = memberId
},
new Metadata {
{ PitRequestHeaderName, leaderPit }
}).InviteId;
Assert.NotNull(inviteAnotherPlayer);
invitesList.Add(inviteAnotherPlayer);
leaderIdToMembers.TryAdd(leaderId, new List <string>());
leaderIdToMembers[leaderId].Add(memberId);
playerPits[memberId] = memberPit;
_partyClient.JoinParty(new JoinPartyRequest {
PartyId = partyId
},
new Metadata {
{ PitRequestHeaderName, memberPit }
});
}
}
// The three leaders perform a Join request for their parties.
foreach (var leaderId in leaderIds)
{
_gatewayClient.Join(new JoinRequest
{
MatchmakingType = "match3"
}, new Metadata {
{ PitRequestHeaderName, playerPits[leaderId] }
});
}
AssertWithinSeconds(20, () =>
{
foreach (var leaderId in leaderIds)
{
var leaderPit = playerPits[leaderId];
var leaderOp = _operationsClient.GetOperation(leaderId,
CallSettings.FromHeader(PitRequestHeaderName, leaderPit));
if (!leaderOp.Done)
{
return(false);
}
// If the matchmaking op is done for the leader, other members' ops should also be completed.
var partyOps = new List <Operation> {
leaderOp
};
foreach (var memberId in leaderIdToMembers[leaderId])
{
if (memberId == leaderId)
{
continue;
}
var memberOp = _operationsClient.GetOperation(memberId,
CallSettings.FromHeader(PitRequestHeaderName, playerPits[memberId]));
if (!memberOp.Done)
{
Assert.Fail(
$"The leader has finalized matchmaking but one of the members ({memberId}) has not");
return(false);
}
partyOps.Add(memberOp);
}
// None of the members should have gotten an Error code.
foreach (var op in partyOps)
{
if (op.Error != null)
{
Assert.Fail($"Op returned error code: {op.Error.Code}");
return(false);
}
}
// All members of the party should have the same deployment info as the leader. Their login tokens
// should have been generated.
var leaderDeployment = leaderOp.Response.Unpack <JoinResponse>().DeploymentName;
foreach (var op in partyOps)
{
var joinResponse = op.Response.Unpack <JoinResponse>();
Assert.AreEqual(leaderDeployment, joinResponse.DeploymentName);
Assert.False(string.IsNullOrEmpty(joinResponse.LoginToken));
}
}
return(true);
});
// Delete the three parties which have been created.
foreach (var leaderId in leaderIds)
{
_partyClient.DeleteParty(new DeletePartyRequest(),
new Metadata {
{ PitRequestHeaderName, playerPits[leaderId] }
});
}
}
public void AllowAJoinRequestToBeDeletedAndNewMembersInvited()
{
// Create a solo party and get its ID to later invite another player.
var partyId = _partyClient.CreateParty(new CreatePartyRequest(), _leaderMetadata).PartyId;
// Join matchmaking.
var op = _gatewayClient.Join(new JoinRequest
{
MatchmakingType = "no_match"
}, _leaderMetadata);
Assert.AreEqual(LeaderPlayerId, op.Name);
Assert.False(op.Done);
// Verify that the party has not been matched yet.
var fetchedOp = _operationsClient.GetOperation(LeaderPlayerId,
CallSettings.FromHeader(PitRequestHeaderName, _leaderPit));
Assert.AreEqual(LeaderPlayerId, fetchedOp.Name);
Assert.False(fetchedOp.Done);
// Cancel matchmaking.
_operationsClient.DeleteOperation(LeaderPlayerId,
CallSettings.FromHeader(PitRequestHeaderName, _leaderPit));
// Verify that there is no more information within the matchmaking system about the party/player.
var rpcException = Assert.Throws <RpcException>(() =>
_operationsClient.GetOperation(LeaderPlayerId,
CallSettings.FromHeader(PitRequestHeaderName, _leaderPit)));
Assert.AreEqual(StatusCode.NotFound, rpcException.Status.StatusCode);
// Verify that we can invite another member to the party
var pitAnotherMember = CreatePlayerIdentityTokenForPlayer(MemberPlayerId);
var inviteAnotherPlayer = _inviteClient.CreateInvite(new CreateInviteRequest {
ReceiverPlayerId = MemberPlayerId
},
_leaderMetadata).InviteId;
Assert.NotNull(inviteAnotherPlayer);
_partyClient.JoinParty(new JoinPartyRequest {
PartyId = partyId
},
new Metadata {
{ PitRequestHeaderName, pitAnotherMember }
});
// Join matchmaking for the second time.
var opSecond = _gatewayClient.Join(new JoinRequest
{
MatchmakingType = "no_match"
}, _leaderMetadata);
Assert.AreEqual(LeaderPlayerId, opSecond.Name);
Assert.False(opSecond.Done);
// Verify that the party has not been matched yet.
fetchedOp = _operationsClient.GetOperation(LeaderPlayerId,
CallSettings.FromHeader(PitRequestHeaderName, _leaderPit));
Assert.AreEqual(LeaderPlayerId, fetchedOp.Name);
Assert.False(fetchedOp.Done);
// Cancel matchmaking.
_operationsClient.DeleteOperation(LeaderPlayerId,
CallSettings.FromHeader(PitRequestHeaderName, _leaderPit));
// Clean-up.
_partyClient.DeleteParty(new DeletePartyRequest(), _leaderMetadata);
}
public async Task AllowOneThousandPlayersToMatchAtOnce()
{
const int playersPerParty = 1;
const int parties = 1000;
var startTime = DateTime.UtcNow;
var tasks = new List <Task>();
for (var i = 0; i < playersPerParty * parties; i++)
{
var myId = i;
var playerName = $"test_player_{startTime.ToLongTimeString()}_{myId}";
var playerPit = await CreatePlayerIdentityTokenForPlayer(playerName);
var task = Task.Run(async() =>
{
var playerMetadata = new Metadata {
{ PitRequestHeaderName, playerPit }
};
if (myId % playersPerParty == 0)
{
// Lead player sets up the match and invites the others
var party = false;
while (!party)
{
try
{
GetPartyClient().CreateParty(new CreatePartyRequest(), playerMetadata);
party = true;
}
catch (RpcException e)
{
Console.WriteLine($"CreateParty exception: {e}");
}
}
for (var j = 0; j < playersPerParty - 1; j++)
{
var invitedPlayerId = $"test_player_{startTime}_{myId + j + 1}";
GetInviteClient().CreateInvite(new CreateInviteRequest
{
ReceiverPlayerId = invitedPlayerId
}, playerMetadata);
}
int members = 1;
while (members < playersPerParty)
{
var partyData =
GetPartyClient().GetPartyByPlayerId(new GetPartyByPlayerIdRequest(), playerMetadata);
members = partyData.Party.MemberIds.Count;
await Task.Delay(500);
}
Console.WriteLine($"Enough players joined: Continuing as master ({playerName})");
// Join matchmaking.
var joined = false;
while (!joined)
{
try
{
GetGatewayClient().Join(new JoinRequest
{
MatchmakingType = "match1"
}, playerMetadata);
joined = true;
}
catch (RpcException e)
{
if (e.StatusCode == StatusCode.AlreadyExists)
{
joined = true;
}
Console.WriteLine($"Exception in Join ({playerName}): {e}");
}
}
}
else
{
// All other players wait for an invite
Console.WriteLine("Beginning as player");
var joined = false;
do
{
var invites = GetInviteClient().ListAllInvites(new ListAllInvitesRequest(), playerMetadata);
if (invites.InboundInvites.Count > 0)
{
_ = GetPartyClient().JoinParty(new JoinPartyRequest
{
PartyId = invites.InboundInvites[0].PartyId
}, playerMetadata);
joined = true;
}
} while (!joined);
}
}).ContinueWith(async t =>
{
// Non-leaders may not have started matchmaking yet so GetOperation could fail a few times.
Operation op = null;
do
{
try
{
op = GetOperationsClient().GetOperation(new GetOperationRequest {
Name = playerName
},
CallSettings.FromHeader(PitRequestHeaderName, playerPit));
}
catch (Exception e)
{
Console.WriteLine($"Failed to poll: {e}");
}
await Task.Delay(100);
} while (op == null || !op.Done);
}).ContinueWith(t =>
{
var playerMetadata = new Metadata {
{ PitRequestHeaderName, playerPit }
};
GetPartyClient().DeleteParty(new DeletePartyRequest(), playerMetadata);
});
tasks.Add(task);
}
Task.WaitAll(tasks.ToArray());
var seconds = (DateTime.UtcNow - startTime).TotalSeconds;
Console.WriteLine($"Test completed in {seconds}s");
Assert.Less(seconds, TimeSpan.FromMinutes(2).TotalSeconds);
}
