/// <summary> /// <para> Creates a new LoadBalancer. </para> <para> Once the call has completed successfully, a new LoadBalancer is created; however, it will /// not be usable until at least one instance has been registered. When the LoadBalancer creation is completed, the client can check whether or /// not it is usable by using the DescribeInstanceHealth API. The LoadBalancer is usable as soon as any registered instance is <i>InService</i> /// . /// </para> <para><b>NOTE:</b> Currently, the client's quota of LoadBalancers is limited to five per Region. </para> <para><b>NOTE:</b> /// Load balancer DNS names vary depending on the Region they're created in. For load balancers created in the United States, the DNS name ends /// with: us-east-1.elb.amazonaws.com (for the US Standard Region) us-west-1.elb.amazonaws.com (for the Northern California Region) For load /// balancers created in the EU (Ireland) Region, the DNS name ends with: eu-west-1.elb.amazonaws.com </para> /// </summary> /// /// <param name="createLoadBalancerRequest">Container for the necessary parameters to execute the CreateLoadBalancer service method on /// AmazonElasticLoadBalancing.</param> /// /// <returns>The response from the CreateLoadBalancer service method, as returned by AmazonElasticLoadBalancing.</returns> /// /// <exception cref="TooManyLoadBalancersException"/> /// <exception cref="InvalidConfigurationRequestException"/> /// <exception cref="CertificateNotFoundException"/> /// <exception cref="DuplicateLoadBalancerNameException"/> public CreateLoadBalancerResponse CreateLoadBalancer(CreateLoadBalancerRequest createLoadBalancerRequest) { IRequest <CreateLoadBalancerRequest> request = new CreateLoadBalancerRequestMarshaller().Marshall(createLoadBalancerRequest); CreateLoadBalancerResponse response = Invoke <CreateLoadBalancerRequest, CreateLoadBalancerResponse> (request, this.signer, CreateLoadBalancerResponseUnmarshaller.GetInstance()); return(response); }
public void CreateLoadBalancerMarshallTest() { var operation = service_model.FindOperation("CreateLoadBalancer"); var request = InstantiateClassGenerator.Execute <CreateLoadBalancerRequest>(); var marshaller = new CreateLoadBalancerRequestMarshaller(); var internalRequest = marshaller.Marshall(request); var validator = new AWSQueryValidator(internalRequest.Parameters, request, service_model, operation); validator.Validate(); var payloadResponse = new XmlSampleGenerator(service_model, operation).Execute(); var context = new XmlUnmarshallerContext(Utils.CreateStreamFromString(payloadResponse), false, null); var response = CreateLoadBalancerResponseUnmarshaller.Instance.Unmarshall(context) as CreateLoadBalancerResponse; InstantiateClassGenerator.ValidateObjectFullyInstantiated(response); }
/// <summary> /// Initiates the asynchronous execution of the CreateLoadBalancer operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the CreateLoadBalancer operation.</param> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> /// <returns>The task object representing the asynchronous operation.</returns> public Task<CreateLoadBalancerResponse> CreateLoadBalancerAsync(CreateLoadBalancerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new CreateLoadBalancerRequestMarshaller(); var unmarshaller = CreateLoadBalancerResponseUnmarshaller.Instance; return InvokeAsync<CreateLoadBalancerRequest,CreateLoadBalancerResponse>(request, marshaller, unmarshaller, cancellationToken); }
internal CreateLoadBalancerResponse CreateLoadBalancer(CreateLoadBalancerRequest request) { var marshaller = new CreateLoadBalancerRequestMarshaller(); var unmarshaller = CreateLoadBalancerResponseUnmarshaller.Instance; return Invoke<CreateLoadBalancerRequest,CreateLoadBalancerResponse>(request, marshaller, unmarshaller); }
IAsyncResult invokeCreateLoadBalancer(CreateLoadBalancerRequest createLoadBalancerRequest, AsyncCallback callback, object state, bool synchronized) { IRequest irequest = new CreateLoadBalancerRequestMarshaller().Marshall(createLoadBalancerRequest); var unmarshaller = CreateLoadBalancerResponseUnmarshaller.GetInstance(); AsyncResult result = new AsyncResult(irequest, callback, state, synchronized, signer, unmarshaller); Invoke(result); return result; }
/// <summary> /// <para> Creates a new load balancer. </para> <para> After the call has completed successfully, a new load balancer is created with a unique /// Domain Name Service (DNS) name. The DNS name includes the name of the AWS region in which the load balance was created. For example, if your /// load balancer was created in the United States, the DNS name might end with either of the following:</para> /// <ul> /// <li> <i>us-east-1.elb.amazonaws.com</i> (for the Northern Virginia Region) </li> /// <li> <i>us-west-1.elb.amazonaws.com</i> (for the Northern California Region) </li> /// /// </ul> /// <para>For information about the AWS regions supported by Elastic Load Balancing, see <a href="http://docs.aws.amazon.com/general/latest/gr/rande.html#elb_region">Regions and Endpoints</a> .</para> <para>You can create up to 10 /// load balancers per region per account.</para> <para>Elastic Load Balancing supports load balancing your Amazon EC2 instances launched within /// any one of the following platforms:</para> /// <ul> /// <li> <i>EC2-Classic</i> <para>For information on creating and managing your load balancers in EC2-Classic, see <a href="http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/UserScenariosForEC2.html">Deploy Elastic Load Balancing in /// Amazon EC2-Classic</a> .</para> </li> /// <li> <i>EC2-VPC</i> <para>For information on creating and managing your load balancers in EC2-VPC, see <a href="http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/UserScenariosForVPC.html">Deploy Elastic Load Balancing in /// Amazon VPC</a> .</para> </li> /// /// </ul> /// </summary> /// /// <param name="createLoadBalancerRequest">Container for the necessary parameters to execute the CreateLoadBalancer service method on /// AmazonElasticLoadBalancing.</param> /// /// <returns>The response from the CreateLoadBalancer service method, as returned by AmazonElasticLoadBalancing.</returns> /// /// <exception cref="T:Amazon.ElasticLoadBalancing.Model.InvalidSubnetException" /> /// <exception cref="T:Amazon.ElasticLoadBalancing.Model.InvalidConfigurationRequestException" /> /// <exception cref="T:Amazon.ElasticLoadBalancing.Model.InvalidSecurityGroupException" /> /// <exception cref="T:Amazon.ElasticLoadBalancing.Model.CertificateNotFoundException" /> /// <exception cref="T:Amazon.ElasticLoadBalancing.Model.InvalidSchemeException" /> /// <exception cref="T:Amazon.ElasticLoadBalancing.Model.DuplicateLoadBalancerNameException" /> /// <exception cref="T:Amazon.ElasticLoadBalancing.Model.TooManyLoadBalancersException" /> /// <exception cref="T:Amazon.ElasticLoadBalancing.Model.SubnetNotFoundException" /> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> public async Task<CreateLoadBalancerResponse> CreateLoadBalancerAsync(CreateLoadBalancerRequest createLoadBalancerRequest, CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new CreateLoadBalancerRequestMarshaller(); var unmarshaller = CreateLoadBalancerResponseUnmarshaller.GetInstance(); var response = await Invoke<IRequest, CreateLoadBalancerRequest, CreateLoadBalancerResponse>(createLoadBalancerRequest, marshaller, unmarshaller, signer, cancellationToken) .ConfigureAwait(continueOnCapturedContext: false); return response; }
/// <summary> /// <para> Creates a new LoadBalancer. </para> <para> Once the call has /// completed successfully, a new LoadBalancer is created; however, it /// will not be usable until at least one instance has been registered. /// When the LoadBalancer creation is completed, the client can check /// whether or not it is usable by using the DescribeInstanceHealth API. /// The LoadBalancer is usable as soon as any registered instance is /// <i>InService</i> . /// </para> <para><b>NOTE:</b> Currently, the client's quota of /// LoadBalancers is limited to five per Region. </para> /// <para><b>NOTE:</b> Load balancer DNS names vary depending on the /// Region they're created in. For load balancers created in the United /// States, the DNS name ends with: us-east-1.elb.amazonaws.com (for the /// US Standard Region) us-west-1.elb.amazonaws.com (for the Northern /// California Region) For load balancers created in the EU (Ireland) /// Region, the DNS name ends with: eu-west-1.elb.amazonaws.com </para> /// </summary> /// /// <param name="createLoadBalancerRequest">Container for the necessary /// parameters to execute the CreateLoadBalancer service method on /// AmazonElasticLoadBalancing.</param> /// /// <returns>The response from the CreateLoadBalancer service method, as /// returned by AmazonElasticLoadBalancing.</returns> /// /// <exception cref="TooManyLoadBalancersException"/> /// <exception cref="DuplicateLoadBalancerNameException"/> /// <exception cref="CertificateNotFoundException"/> /// <exception cref="InvalidConfigurationRequestException"/> public CreateLoadBalancerResponse CreateLoadBalancer(CreateLoadBalancerRequest createLoadBalancerRequest) { IRequest<CreateLoadBalancerRequest> request = new CreateLoadBalancerRequestMarshaller().Marshall(createLoadBalancerRequest); CreateLoadBalancerResponse response = Invoke<CreateLoadBalancerRequest, CreateLoadBalancerResponse> (request, this.signer, CreateLoadBalancerResponseUnmarshaller.GetInstance()); return response; }
/// <summary> /// Initiates the asynchronous execution of the CreateLoadBalancer operation. /// <seealso cref="Amazon.ElasticLoadBalancing.IAmazonElasticLoadBalancing.CreateLoadBalancer"/> /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the CreateLoadBalancer operation.</param> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> /// <returns>The task object representing the asynchronous operation.</returns> public Task<CreateLoadBalancerResponse> CreateLoadBalancerAsync(CreateLoadBalancerRequest request, CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new CreateLoadBalancerRequestMarshaller(); var unmarshaller = CreateLoadBalancerResponseUnmarshaller.GetInstance(); return Invoke<IRequest, CreateLoadBalancerRequest, CreateLoadBalancerResponse>(request, marshaller, unmarshaller, signer, cancellationToken); }
public void CreateLoadBalancerMarshallTest() { var operation = service_model.FindOperation("CreateLoadBalancer"); var request = InstantiateClassGenerator.Execute<CreateLoadBalancerRequest>(); var marshaller = new CreateLoadBalancerRequestMarshaller(); var internalRequest = marshaller.Marshall(request); var validator = new AWSQueryValidator(internalRequest.Parameters, request, service_model, operation); validator.Validate(); var payloadResponse = new XmlSampleGenerator(service_model, operation).Execute(); var context = new XmlUnmarshallerContext(Utils.CreateStreamFromString(payloadResponse), false, null); var response = CreateLoadBalancerResponseUnmarshaller.Instance.Unmarshall(context) as CreateLoadBalancerResponse; InstantiateClassGenerator.ValidateObjectFullyInstantiated(response); }
IAsyncResult invokeCreateLoadBalancer(CreateLoadBalancerRequest request, AsyncCallback callback, object state, bool synchronized) { var marshaller = new CreateLoadBalancerRequestMarshaller(); var unmarshaller = CreateLoadBalancerResponseUnmarshaller.Instance; return Invoke(request, callback, state, synchronized, marshaller, unmarshaller, signer); }
/// <summary> /// Initiates the asynchronous execution of the CreateLoadBalancer operation. /// <seealso cref="Amazon.ElasticLoadBalancing.IAmazonElasticLoadBalancing"/> /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the CreateLoadBalancer operation on AmazonElasticLoadBalancingClient.</param> /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param> /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property.</param> /// /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateLoadBalancer /// operation.</returns> public IAsyncResult BeginCreateLoadBalancer(CreateLoadBalancerRequest request, AsyncCallback callback, object state) { var marshaller = new CreateLoadBalancerRequestMarshaller(); var unmarshaller = CreateLoadBalancerResponseUnmarshaller.Instance; return BeginInvoke<CreateLoadBalancerRequest>(request, marshaller, unmarshaller, callback, state); }