/// <summary>Snippet for DeleteRealmAsync</summary>
public async Task DeleteRealmResourceNamesAsync()
{
// Snippet: DeleteRealmAsync(RealmName, CallSettings)
// Additional: DeleteRealmAsync(RealmName, CancellationToken)
// Create client
RealmsServiceClient realmsServiceClient = await RealmsServiceClient.CreateAsync();
// Initialize request argument(s)
RealmName name = RealmName.FromProjectLocationRealm("[PROJECT]", "[LOCATION]", "[REALM]");
// Make the request
Operation <Empty, OperationMetadata> response = await realmsServiceClient.DeleteRealmAsync(name);
// Poll until the returned long-running operation is complete
Operation <Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation <Empty, OperationMetadata> retrievedResponse = await realmsServiceClient.PollOnceDeleteRealmAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Empty retrievedResult = retrievedResponse.Result;
}
// End snippet
}
public async stt::Task PreviewCreateGameServerClusterRequestObjectAsync()
{
moq::Mock <GameServerClustersService.GameServerClustersServiceClient> mockGrpcClient = new moq::Mock <GameServerClustersService.GameServerClustersServiceClient>(moq::MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
PreviewCreateGameServerClusterRequest request = new PreviewCreateGameServerClusterRequest
{
ParentAsRealmName = RealmName.FromProjectLocationRealm("[PROJECT]", "[LOCATION]", "[REALM]"),
GameServerClusterId = "game_server_cluster_ida2310829",
GameServerCluster = new GameServerCluster(),
PreviewTime = new wkt::Timestamp(),
};
PreviewCreateGameServerClusterResponse expectedResponse = new PreviewCreateGameServerClusterResponse
{
Etag = "etage8ad7218",
TargetState = new TargetState(),
};
mockGrpcClient.Setup(x => x.PreviewCreateGameServerClusterAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <PreviewCreateGameServerClusterResponse>(stt::Task.FromResult(expectedResponse), null, null, null, null));
GameServerClustersServiceClient client = new GameServerClustersServiceClientImpl(mockGrpcClient.Object, null);
PreviewCreateGameServerClusterResponse responseCallSettings = await client.PreviewCreateGameServerClusterAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
xunit::Assert.Same(expectedResponse, responseCallSettings);
PreviewCreateGameServerClusterResponse responseCancellationToken = await client.PreviewCreateGameServerClusterAsync(request, st::CancellationToken.None);
xunit::Assert.Same(expectedResponse, responseCancellationToken);
mockGrpcClient.VerifyAll();
}
/// <summary>Snippet for DeleteRealm</summary>
public void DeleteRealmRequestObject()
{
// Snippet: DeleteRealm(DeleteRealmRequest, CallSettings)
// Create client
RealmsServiceClient realmsServiceClient = RealmsServiceClient.Create();
// Initialize request argument(s)
DeleteRealmRequest request = new DeleteRealmRequest
{
RealmName = RealmName.FromProjectLocationRealm("[PROJECT]", "[LOCATION]", "[REALM]"),
};
// Make the request
Operation <Empty, OperationMetadata> response = realmsServiceClient.DeleteRealm(request);
// Poll until the returned long-running operation is complete
Operation <Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation <Empty, OperationMetadata> retrievedResponse = realmsServiceClient.PollOnceDeleteRealm(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Empty retrievedResult = retrievedResponse.Result;
}
// End snippet
}
public async Task <Realm> UpdateRealmAsync(
string projectId, string regionId, string realmId)
{
// Create the client.
RealmsServiceClient client = await RealmsServiceClient.CreateAsync();
Realm realm = new Realm
{
RealmName = RealmName.FromProjectLocationRealm(projectId, regionId, realmId),
};
realm.Labels.Add("label-key-1", "label-value-1");
realm.Labels.Add("label-key-2", "label-value-2");
UpdateRealmRequest request = new UpdateRealmRequest
{
Realm = realm,
UpdateMask = new FieldMask {
Paths = { "labels" }
}
};
// Make the request.
Operation <Realm, OperationMetadata> response = await client.UpdateRealmAsync(request);
Operation <Realm, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result. This result will NOT contain the updated labels.
// If you want to get the updated resource, use a GET request on the resource.
return(completedResponse.Result);
}
public void PreviewCreateGameServerClusterRequestObject()
{
moq::Mock <GameServerClustersService.GameServerClustersServiceClient> mockGrpcClient = new moq::Mock <GameServerClustersService.GameServerClustersServiceClient>(moq::MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
PreviewCreateGameServerClusterRequest request = new PreviewCreateGameServerClusterRequest
{
ParentAsRealmName = RealmName.FromProjectLocationRealm("[PROJECT]", "[LOCATION]", "[REALM]"),
GameServerClusterId = "game_server_cluster_ida2310829",
GameServerCluster = new GameServerCluster(),
PreviewTime = new wkt::Timestamp(),
};
PreviewCreateGameServerClusterResponse expectedResponse = new PreviewCreateGameServerClusterResponse
{
Etag = "etage8ad7218",
TargetState = new TargetState(),
};
mockGrpcClient.Setup(x => x.PreviewCreateGameServerCluster(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
GameServerClustersServiceClient client = new GameServerClustersServiceClientImpl(mockGrpcClient.Object, null);
PreviewCreateGameServerClusterResponse response = client.PreviewCreateGameServerCluster(request);
xunit::Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public void GetRealmRequestObject()
{
moq::Mock <RealmsService.RealmsServiceClient> mockGrpcClient = new moq::Mock <RealmsService.RealmsServiceClient>(moq::MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
GetRealmRequest request = new GetRealmRequest
{
RealmName = RealmName.FromProjectLocationRealm("[PROJECT]", "[LOCATION]", "[REALM]"),
};
Realm expectedResponse = new Realm
{
RealmName = RealmName.FromProjectLocationRealm("[PROJECT]", "[LOCATION]", "[REALM]"),
CreateTime = new wkt::Timestamp(),
UpdateTime = new wkt::Timestamp(),
Labels =
{
{
"key8a0b6e3c",
"value60c16320"
},
},
TimeZone = "time_zone73f23b20",
Etag = "etage8ad7218",
Description = "description2cf9da67",
};
mockGrpcClient.Setup(x => x.GetRealm(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
RealmsServiceClient client = new RealmsServiceClientImpl(mockGrpcClient.Object, null);
Realm response = client.GetRealm(request);
xunit::Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public async Task <Realm> CreateRealmAsync(
string projectId, string regionId, string realmId)
{
// Create the client.
RealmsServiceClient client = await RealmsServiceClient.CreateAsync();
Realm realm = new Realm
{
RealmName = RealmName.FromProjectLocationRealm(projectId, regionId, realmId),
TimeZone = "America/Los_Angeles"
};
CreateRealmRequest request = new CreateRealmRequest
{
ParentAsLocationName = LocationName.FromProjectLocation(projectId, regionId),
RealmId = realmId,
Realm = realm
};
// Make the request.
Operation <Realm, OperationMetadata> response = await client.CreateRealmAsync(request);
// Poll until the returned long-running operation is complete.
Operation <Realm, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result.
return(completedResponse.Result);
}
public async Task <GameServerCluster> CreateClusterAsync(
string projectId, string regionId, string realmId, string clusterId, string gkeName)
{
// Create the client.
GameServerClustersServiceClient client = await GameServerClustersServiceClient.CreateAsync();
GameServerCluster cluster = new GameServerCluster()
{
GameServerClusterName = GameServerClusterName.FromProjectLocationRealmCluster(projectId, regionId, realmId, clusterId),
ConnectionInfo = new GameServerClusterConnectionInfo
{
GkeClusterReference = new GkeClusterReference
{
Cluster = gkeName
},
Namespace = "default"
}
};
CreateGameServerClusterRequest request = new CreateGameServerClusterRequest
{
ParentAsRealmName = RealmName.FromProjectLocationRealm(projectId, regionId, realmId),
GameServerClusterId = clusterId,
GameServerCluster = cluster
};
// Make the request.
Operation <GameServerCluster, OperationMetadata> response = await client.CreateGameServerClusterAsync(request);
// Poll until the returned long-running operation is complete.
Operation <GameServerCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result.
return(completedResponse.Result);
}
/// <summary>Snippet for GetRealm</summary>
public void GetRealmResourceNames()
{
// Snippet: GetRealm(RealmName, CallSettings)
// Create client
RealmsServiceClient realmsServiceClient = RealmsServiceClient.Create();
// Initialize request argument(s)
RealmName name = RealmName.FromProjectLocationRealm("[PROJECT]", "[LOCATION]", "[REALM]");
// Make the request
Realm response = realmsServiceClient.GetRealm(name);
// End snippet
}
/// <summary>Snippet for GetRealmAsync</summary>
public async Task GetRealmResourceNamesAsync()
{
// Snippet: GetRealmAsync(RealmName, CallSettings)
// Additional: GetRealmAsync(RealmName, CancellationToken)
// Create client
RealmsServiceClient realmsServiceClient = await RealmsServiceClient.CreateAsync();
// Initialize request argument(s)
RealmName name = RealmName.FromProjectLocationRealm("[PROJECT]", "[LOCATION]", "[REALM]");
// Make the request
Realm response = await realmsServiceClient.GetRealmAsync(name);
// End snippet
}
/// <summary>Snippet for GetRealm</summary>
public void GetRealmRequestObject()
{
// Snippet: GetRealm(GetRealmRequest, CallSettings)
// Create client
RealmsServiceClient realmsServiceClient = RealmsServiceClient.Create();
// Initialize request argument(s)
GetRealmRequest request = new GetRealmRequest
{
RealmName = RealmName.FromProjectLocationRealm("[PROJECT]", "[LOCATION]", "[REALM]"),
};
// Make the request
Realm response = realmsServiceClient.GetRealm(request);
// End snippet
}
public Realm GetRealm(
string projectId, string regionId, string realmId)
{
// Create the client.
RealmsServiceClient client = RealmsServiceClient.Create();
GetRealmRequest request = new GetRealmRequest
{
RealmName = RealmName.FromProjectLocationRealm(projectId, regionId, realmId)
};
// Make the request.
Realm response = client.GetRealm(request);
return(response);
}
public void DeleteRealm(
string projectId, string regionId, string realmId)
{
// Create the client.
RealmsServiceClient client = RealmsServiceClient.Create();
DeleteRealmRequest request = new DeleteRealmRequest
{
RealmName = RealmName.FromProjectLocationRealm(projectId, regionId, realmId)
};
// Make the request.
Operation <Empty, OperationMetadata> response = client.DeleteRealm(request);
// Poll until the returned long-running operation is complete.
response.PollUntilCompleted();
}
public IList <GameServerCluster> ListClusters(
string projectId, string regionId, string realmId)
{
// Create the client.
GameServerClustersServiceClient client = GameServerClustersServiceClient.Create();
ListGameServerClustersRequest request = new ListGameServerClustersRequest
{
ParentAsRealmName = RealmName.FromProjectLocationRealm(projectId, regionId, realmId),
View = GameServerClusterView.Full
};
// Make the request.
PagedEnumerable <ListGameServerClustersResponse, GameServerCluster> response = client.ListGameServerClusters(request);
// You could iterate through response and write the cluster.Name and
// cluster.ClusterState to the console to see the installed versions of Agones
// and Kubernetes on each cluster.
// The returned sequence will lazily perform RPCs as it's being iterated over.
return(response.ToList());
}
public async Task <GameServerDeployment> UpdateRolloutOverrideConfigAsync(
string projectId, string deploymentId, string configId, string realmRegionId, string realmId)
{
// Create the client.
GameServerDeploymentsServiceClient client = await GameServerDeploymentsServiceClient.CreateAsync();
GameServerConfigOverride configOverride = new GameServerConfigOverride
{
ConfigVersion = configId,
RealmsSelector = new RealmSelector()
};
configOverride.RealmsSelector.Realms.Add(RealmName.FormatProjectLocationRealm(projectId, realmRegionId, realmId));
GameServerDeploymentRollout rollout = new GameServerDeploymentRollout
{
Name = GameServerDeploymentName.FormatProjectLocationDeployment(projectId, "global", deploymentId)
};
rollout.GameServerConfigOverrides.Add(configOverride);
UpdateGameServerDeploymentRolloutRequest request = new UpdateGameServerDeploymentRolloutRequest
{
Rollout = rollout,
UpdateMask = new FieldMask {
Paths = { "game_server_config_overrides" }
}
};
// Make the request.
Operation <GameServerDeployment, OperationMetadata> response = await client.UpdateGameServerDeploymentRolloutAsync(request);
Operation <GameServerDeployment, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result.
return(completedResponse.Result);
}
public async stt::Task GetRealmRequestObjectAsync()
{
moq::Mock <RealmsService.RealmsServiceClient> mockGrpcClient = new moq::Mock <RealmsService.RealmsServiceClient>(moq::MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
GetRealmRequest request = new GetRealmRequest
{
RealmName = RealmName.FromProjectLocationRealm("[PROJECT]", "[LOCATION]", "[REALM]"),
};
Realm expectedResponse = new Realm
{
RealmName = RealmName.FromProjectLocationRealm("[PROJECT]", "[LOCATION]", "[REALM]"),
CreateTime = new wkt::Timestamp(),
UpdateTime = new wkt::Timestamp(),
Labels =
{
{
"key8a0b6e3c",
"value60c16320"
},
},
TimeZone = "time_zone73f23b20",
Etag = "etage8ad7218",
Description = "description2cf9da67",
};
mockGrpcClient.Setup(x => x.GetRealmAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <Realm>(stt::Task.FromResult(expectedResponse), null, null, null, null));
RealmsServiceClient client = new RealmsServiceClientImpl(mockGrpcClient.Object, null);
Realm responseCallSettings = await client.GetRealmAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
xunit::Assert.Same(expectedResponse, responseCallSettings);
Realm responseCancellationToken = await client.GetRealmAsync(request, st::CancellationToken.None);
xunit::Assert.Same(expectedResponse, responseCancellationToken);
mockGrpcClient.VerifyAll();
}
