/// <summary> /// Creates a ForwardingRule resource in the specified project and region using the data included in the request. /// Documentation https://developers.google.com/compute/alpha/reference/globalForwardingRules/insert /// Generation Note: This does not always build corectly. Google needs to standardise things I need to figuer out which ones are wrong. /// </summary> /// <param name="service">Authenticated compute service.</param> /// <param name="project">Project ID for this request.</param> /// <param name="body">A valid compute alpha body.</param> /// <returns>OperationResponse</returns> public static Operation Insert(computeService service, string project, ForwardingRule body) { try { // Initial validation. if (service == null) { throw new ArgumentNullException("service"); } if (body == null) { throw new ArgumentNullException("body"); } if (project == null) { throw new ArgumentNullException(project); } // Make the request. return(service.GlobalForwardingRules.Insert(body, project).Execute()); } catch (Exception ex) { throw new Exception("Request GlobalForwardingRules.Insert failed.", ex); } }
/// <summary> /// Creates a GlobalForwardingRule resource in the specified project using the data included in the request. /// Documentation https://developers.google.com/compute/alpha/reference/globalForwardingRules/insert /// Generation Note: This does not always build corectly. Google needs to standardise things I need to figuer out which ones are wrong. /// </summary> /// <param name="service">Authenticated Compute service.</param> /// <param name="project">Project ID for this request.</param> /// <param name="body">A valid Compute alpha body.</param> /// <param name="optional">Optional paramaters.</param> /// <returns>OperationResponse</returns> public static Operation Insert(ComputeService service, string project, ForwardingRule body, GlobalForwardingRulesInsertOptionalParms optional = null) { try { // Initial validation. if (service == null) { throw new ArgumentNullException("service"); } if (body == null) { throw new ArgumentNullException("body"); } if (project == null) { throw new ArgumentNullException(project); } // Building the initial request. var request = service.GlobalForwardingRules.Insert(body, project); // Applying optional parameters to the request. request = (GlobalForwardingRulesResource.InsertRequest)SampleHelpers.ApplyOptionalParms(request, optional); // Requesting data. return(request.Execute()); } catch (Exception ex) { throw new Exception("Request GlobalForwardingRules.Insert failed.", ex); } }
/// <summary>Snippet for PatchAsync</summary> public async Task PatchAsync() { // Snippet: PatchAsync(string, string, ForwardingRule, CallSettings) // Additional: PatchAsync(string, string, ForwardingRule, CancellationToken) // Create client GlobalForwardingRulesClient globalForwardingRulesClient = await GlobalForwardingRulesClient.CreateAsync(); // Initialize request argument(s) string project = ""; string forwardingRule = ""; ForwardingRule forwardingRuleResource = new ForwardingRule(); // Make the request lro::Operation <Operation, Operation> response = await globalForwardingRulesClient.PatchAsync(project, forwardingRule, forwardingRuleResource); // Poll until the returned long-running operation is complete lro::Operation <Operation, Operation> completedResponse = await response.PollUntilCompletedAsync(); // Retrieve the operation result Operation 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 lro::Operation <Operation, Operation> retrievedResponse = await globalForwardingRulesClient.PollOncePatchAsync(operationName); // Check if the retrieved long-running operation has completed if (retrievedResponse.IsCompleted) { // If it has completed, then access the result Operation retrievedResult = retrievedResponse.Result; } // End snippet }
/// <summary>Snippet for Insert</summary> public void Insert() { // Snippet: Insert(string, ForwardingRule, CallSettings) // Create client GlobalForwardingRulesClient globalForwardingRulesClient = GlobalForwardingRulesClient.Create(); // Initialize request argument(s) string project = ""; ForwardingRule forwardingRuleResource = new ForwardingRule(); // Make the request lro::Operation <Operation, Operation> response = globalForwardingRulesClient.Insert(project, forwardingRuleResource); // Poll until the returned long-running operation is complete lro::Operation <Operation, Operation> completedResponse = response.PollUntilCompleted(); // Retrieve the operation result Operation 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 lro::Operation <Operation, Operation> retrievedResponse = globalForwardingRulesClient.PollOnceInsert(operationName); // Check if the retrieved long-running operation has completed if (retrievedResponse.IsCompleted) { // If it has completed, then access the result Operation retrievedResult = retrievedResponse.Result; } // End snippet }
/// <summary>Snippet for Insert</summary> public void Insert() { // Snippet: Insert(string, ForwardingRule, CallSettings) // Create client GlobalForwardingRulesClient globalForwardingRulesClient = GlobalForwardingRulesClient.Create(); // Initialize request argument(s) string project = ""; ForwardingRule forwardingRuleResource = new ForwardingRule(); // Make the request Operation response = globalForwardingRulesClient.Insert(project, forwardingRuleResource); // End snippet }
/// <summary>Snippet for Get</summary> public void Get() { // Snippet: Get(string, string, CallSettings) // Create client GlobalForwardingRulesClient globalForwardingRulesClient = GlobalForwardingRulesClient.Create(); // Initialize request argument(s) string project = ""; string forwardingRule = ""; // Make the request ForwardingRule response = globalForwardingRulesClient.Get(project, forwardingRule); // End snippet }
/// <summary>Snippet for Patch</summary> public void Patch() { // Snippet: Patch(string, string, string, ForwardingRule, CallSettings) // Create client ForwardingRulesClient forwardingRulesClient = ForwardingRulesClient.Create(); // Initialize request argument(s) string project = ""; string region = ""; string forwardingRule = ""; ForwardingRule forwardingRuleResource = new ForwardingRule(); // Make the request Operation response = forwardingRulesClient.Patch(project, region, forwardingRule, forwardingRuleResource); // End snippet }
/// <summary>Snippet for Get</summary> public void GetRequestObject() { // Snippet: Get(GetGlobalForwardingRuleRequest, CallSettings) // Create client GlobalForwardingRulesClient globalForwardingRulesClient = GlobalForwardingRulesClient.Create(); // Initialize request argument(s) GetGlobalForwardingRuleRequest request = new GetGlobalForwardingRuleRequest { ForwardingRule = "", Project = "", }; // Make the request ForwardingRule response = globalForwardingRulesClient.Get(request); // End snippet }
/// <summary>Snippet for InsertAsync</summary> public async Task InsertAsync() { // Snippet: InsertAsync(string, ForwardingRule, CallSettings) // Additional: InsertAsync(string, ForwardingRule, CancellationToken) // Create client GlobalForwardingRulesClient globalForwardingRulesClient = await GlobalForwardingRulesClient.CreateAsync(); // Initialize request argument(s) string project = ""; ForwardingRule forwardingRuleResource = new ForwardingRule(); // Make the request Operation response = await globalForwardingRulesClient.InsertAsync(project, forwardingRuleResource); // End snippet }
/// <summary>Snippet for GetAsync</summary> public async Task GetAsync() { // Snippet: GetAsync(string, string, CallSettings) // Additional: GetAsync(string, string, CancellationToken) // Create client GlobalForwardingRulesClient globalForwardingRulesClient = await GlobalForwardingRulesClient.CreateAsync(); // Initialize request argument(s) string project = ""; string forwardingRule = ""; // Make the request ForwardingRule response = await globalForwardingRulesClient.GetAsync(project, forwardingRule); // End snippet }
/// <summary>Snippet for PatchAsync</summary> public async Task PatchAsync() { // Snippet: PatchAsync(string, string, string, ForwardingRule, CallSettings) // Additional: PatchAsync(string, string, string, ForwardingRule, CancellationToken) // Create client ForwardingRulesClient forwardingRulesClient = await ForwardingRulesClient.CreateAsync(); // Initialize request argument(s) string project = ""; string region = ""; string forwardingRule = ""; ForwardingRule forwardingRuleResource = new ForwardingRule(); // Make the request Operation response = await forwardingRulesClient.PatchAsync(project, region, forwardingRule, forwardingRuleResource); // End snippet }
/// <summary>Snippet for GetAsync</summary> public async Task GetRequestObjectAsync() { // Snippet: GetAsync(GetGlobalForwardingRuleRequest, CallSettings) // Additional: GetAsync(GetGlobalForwardingRuleRequest, CancellationToken) // Create client GlobalForwardingRulesClient globalForwardingRulesClient = await GlobalForwardingRulesClient.CreateAsync(); // Initialize request argument(s) GetGlobalForwardingRuleRequest request = new GetGlobalForwardingRuleRequest { ForwardingRule = "", Project = "", }; // Make the request ForwardingRule response = await globalForwardingRulesClient.GetAsync(request); // End snippet }
public async stt::Task GetRequestObjectAsync() { moq::Mock <GlobalForwardingRules.GlobalForwardingRulesClient> mockGrpcClient = new moq::Mock <GlobalForwardingRules.GlobalForwardingRulesClient>(moq::MockBehavior.Strict); mockGrpcClient.Setup(x => x.CreateOperationsClientForGlobalOperations()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object); GetGlobalForwardingRuleRequest request = new GetGlobalForwardingRuleRequest { Project = "projectaa6ff846", ForwardingRule = "forwarding_rule51d5478e", }; ForwardingRule expectedResponse = new ForwardingRule { Id = 11672635353343658936UL, Kind = "kindf7aa39d9", Name = "name1c9368b0", CreationTimestamp = "creation_timestamp235e59a1", IPAddress = "I_p_addressf1537179", Ports = { "ports9860f047", }, IsMirroringCollector = false, Region = "regionedb20d96", LabelFingerprint = "label_fingerprint06ccff3a", PscConnectionStatus = "psc_connection_status437a3762", Target = "targetaefbae42", PortRange = "port_ranged4420f7d", ServiceDirectoryRegistrations = { new ForwardingRuleServiceDirectoryRegistration(), }, Network = "networkd22ce091", Fingerprint = "fingerprint009e6052", PscConnectionId = 1768355415909345202UL, IpVersion = "ip_versionde91b460", BackendService = "backend_serviceed490d45", Subnetwork = "subnetworkf55bf572", ServiceName = "service_named5df05d5", LoadBalancingScheme = "load_balancing_scheme21346104", ServiceLabel = "service_label5f95d0c0", Description = "description2cf9da67", AllPorts = false, SelfLink = "self_link7e87f12d", MetadataFilters = { new MetadataFilter(), }, IPProtocol = "I_p_protocold854c15f", AllowGlobalAccess = false, Labels = { { "key8a0b6e3c", "value60c16320" }, }, NetworkTier = "network_tiere6fea951", }; mockGrpcClient.Setup(x => x.GetAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <ForwardingRule>(stt::Task.FromResult(expectedResponse), null, null, null, null)); GlobalForwardingRulesClient client = new GlobalForwardingRulesClientImpl(mockGrpcClient.Object, null); ForwardingRule responseCallSettings = await client.GetAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None)); xunit::Assert.Same(expectedResponse, responseCallSettings); ForwardingRule responseCancellationToken = await client.GetAsync(request, st::CancellationToken.None); xunit::Assert.Same(expectedResponse, responseCancellationToken); mockGrpcClient.VerifyAll(); }
public void GetRequestObject() { moq::Mock <ForwardingRules.ForwardingRulesClient> mockGrpcClient = new moq::Mock <ForwardingRules.ForwardingRulesClient>(moq::MockBehavior.Strict); mockGrpcClient.Setup(x => x.CreateOperationsClientForRegionOperations()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object); GetForwardingRuleRequest request = new GetForwardingRuleRequest { Region = "regionedb20d96", Project = "projectaa6ff846", ForwardingRule = "forwarding_rule51d5478e", }; ForwardingRule expectedResponse = new ForwardingRule { Id = 11672635353343658936UL, Kind = "kindf7aa39d9", Name = "name1c9368b0", CreationTimestamp = "creation_timestamp235e59a1", IPAddress = "I_p_addressf1537179", Ports = { "ports9860f047", }, IsMirroringCollector = false, Region = "regionedb20d96", LabelFingerprint = "label_fingerprint06ccff3a", PscConnectionStatus = ForwardingRule.Types.PscConnectionStatus.UndefinedPscConnectionStatus, Target = "targetaefbae42", PortRange = "port_ranged4420f7d", ServiceDirectoryRegistrations = { new ForwardingRuleServiceDirectoryRegistration(), }, Network = "networkd22ce091", Fingerprint = "fingerprint009e6052", PscConnectionId = 1768355415909345202UL, IpVersion = ForwardingRule.Types.IpVersion.UndefinedIpVersion, BackendService = "backend_serviceed490d45", Subnetwork = "subnetworkf55bf572", ServiceName = "service_named5df05d5", LoadBalancingScheme = ForwardingRule.Types.LoadBalancingScheme.UndefinedLoadBalancingScheme, ServiceLabel = "service_label5f95d0c0", Description = "description2cf9da67", AllPorts = false, SelfLink = "self_link7e87f12d", MetadataFilters = { new MetadataFilter(), }, IPProtocol = ForwardingRule.Types.IPProtocol.Udp, AllowGlobalAccess = false, Labels = { { "key8a0b6e3c", "value60c16320" }, }, NetworkTier = ForwardingRule.Types.NetworkTier.Standard, }; mockGrpcClient.Setup(x => x.Get(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse); ForwardingRulesClient client = new ForwardingRulesClientImpl(mockGrpcClient.Object, null); ForwardingRule response = client.Get(request); xunit::Assert.Same(expectedResponse, response); mockGrpcClient.VerifyAll(); }
/// <summary> /// Updates the specified forwarding rule with the data included in the request. This method supports PATCH semantics and uses the JSON merge patch format and processing rules. Currently, you can only patch the network_tier field. /// Documentation https://developers.google.com/compute/alpha/reference/forwardingRules/patch /// Generation Note: This does not always build corectly. Google needs to standardise things I need to figuer out which ones are wrong. /// </summary> /// <param name="service">Authenticated Compute service.</param> /// <param name="project">Project ID for this request.</param> /// <param name="region">Name of the region scoping this request.</param> /// <param name="forwardingRule">Name of the ForwardingRule resource to patch.</param> /// <param name="body">A valid Compute alpha body.</param> /// <param name="optional">Optional paramaters.</param> /// <returns>OperationResponse</returns> public static Operation Patch(ComputeService service, string project, string region, string forwardingRule, ForwardingRule body, ForwardingRulesPatchOptionalParms optional = null) { try { // Initial validation. if (service == null) { throw new ArgumentNullException("service"); } if (body == null) { throw new ArgumentNullException("body"); } if (project == null) { throw new ArgumentNullException(project); } if (region == null) { throw new ArgumentNullException(region); } if (forwardingRule == null) { throw new ArgumentNullException(forwardingRule); } // Building the initial request. var request = service.ForwardingRules.Patch(body, project, region, forwardingRule); // Applying optional parameters to the request. request = (ForwardingRulesResource.PatchRequest)SampleHelpers.ApplyOptionalParms(request, optional); // Requesting data. return(request.Execute()); } catch (Exception ex) { throw new Exception("Request ForwardingRules.Patch failed.", ex); } }