Container for the parameters to the ModifyLoadBalancerAttributes operation. Modifies the attributes of the specified load balancer.

You can modify the load balancer attributes, such as AccessLogs, ConnectionDraining, and CrossZoneLoadBalancing by either enabling or disabling them. Or, you can modify the load balancer attribute ConnectionSettings by specifying an idle connection timeout value for your load balancer.

For more information, see the following in the Classic Load Balancers Guide:

Inheritance: AmazonElasticLoadBalancingRequest
        internal ModifyLoadBalancerAttributesResponse ModifyLoadBalancerAttributes(ModifyLoadBalancerAttributesRequest request)
        {
            var marshaller = new ModifyLoadBalancerAttributesRequestMarshaller();
            var unmarshaller = ModifyLoadBalancerAttributesResponseUnmarshaller.Instance;

            return Invoke<ModifyLoadBalancerAttributesRequest,ModifyLoadBalancerAttributesResponse>(request, marshaller, unmarshaller);
        }
        /// <summary>
        /// Initiates the asynchronous execution of the ModifyLoadBalancerAttributes operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyLoadBalancerAttributes 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<ModifyLoadBalancerAttributesResponse> ModifyLoadBalancerAttributesAsync(ModifyLoadBalancerAttributesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new ModifyLoadBalancerAttributesRequestMarshaller();
            var unmarshaller = ModifyLoadBalancerAttributesResponseUnmarshaller.Instance;

            return InvokeAsync<ModifyLoadBalancerAttributesRequest,ModifyLoadBalancerAttributesResponse>(request, marshaller, 
                unmarshaller, cancellationToken);
        }
Esempio n. 3
0
        public object Execute(ExecutorContext context)
        {
            var cmdletContext = context as CmdletContext;
            // create request
            var request = new Amazon.ElasticLoadBalancing.Model.ModifyLoadBalancerAttributesRequest();


            // populate LoadBalancerAttributes
            var requestLoadBalancerAttributesIsNull = true;

            request.LoadBalancerAttributes = new Amazon.ElasticLoadBalancing.Model.LoadBalancerAttributes();
            List <Amazon.ElasticLoadBalancing.Model.AdditionalAttribute> requestLoadBalancerAttributes_loadBalancerAttributes_AdditionalAttribute = null;

            if (cmdletContext.LoadBalancerAttributes_AdditionalAttribute != null)
            {
                requestLoadBalancerAttributes_loadBalancerAttributes_AdditionalAttribute = cmdletContext.LoadBalancerAttributes_AdditionalAttribute;
            }
            if (requestLoadBalancerAttributes_loadBalancerAttributes_AdditionalAttribute != null)
            {
                request.LoadBalancerAttributes.AdditionalAttributes = requestLoadBalancerAttributes_loadBalancerAttributes_AdditionalAttribute;
                requestLoadBalancerAttributesIsNull = false;
            }
            Amazon.ElasticLoadBalancing.Model.ConnectionSettings requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionSettings = null;

            // populate ConnectionSettings
            var requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionSettingsIsNull = true;

            requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionSettings = new Amazon.ElasticLoadBalancing.Model.ConnectionSettings();
            System.Int32?requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionSettings_connectionSettings_IdleTimeout = null;
            if (cmdletContext.ConnectionSettings_IdleTimeout != null)
            {
                requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionSettings_connectionSettings_IdleTimeout = cmdletContext.ConnectionSettings_IdleTimeout.Value;
            }
            if (requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionSettings_connectionSettings_IdleTimeout != null)
            {
                requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionSettings.IdleTimeout = requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionSettings_connectionSettings_IdleTimeout.Value;
                requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionSettingsIsNull       = false;
            }
            // determine if requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionSettings should be set to null
            if (requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionSettingsIsNull)
            {
                requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionSettings = null;
            }
            if (requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionSettings != null)
            {
                request.LoadBalancerAttributes.ConnectionSettings = requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionSettings;
                requestLoadBalancerAttributesIsNull = false;
            }
            Amazon.ElasticLoadBalancing.Model.CrossZoneLoadBalancing requestLoadBalancerAttributes_loadBalancerAttributes_CrossZoneLoadBalancing = null;

            // populate CrossZoneLoadBalancing
            var requestLoadBalancerAttributes_loadBalancerAttributes_CrossZoneLoadBalancingIsNull = true;

            requestLoadBalancerAttributes_loadBalancerAttributes_CrossZoneLoadBalancing = new Amazon.ElasticLoadBalancing.Model.CrossZoneLoadBalancing();
            System.Boolean?requestLoadBalancerAttributes_loadBalancerAttributes_CrossZoneLoadBalancing_crossZoneLoadBalancing_Enabled = null;
            if (cmdletContext.CrossZoneLoadBalancing_Enabled != null)
            {
                requestLoadBalancerAttributes_loadBalancerAttributes_CrossZoneLoadBalancing_crossZoneLoadBalancing_Enabled = cmdletContext.CrossZoneLoadBalancing_Enabled.Value;
            }
            if (requestLoadBalancerAttributes_loadBalancerAttributes_CrossZoneLoadBalancing_crossZoneLoadBalancing_Enabled != null)
            {
                requestLoadBalancerAttributes_loadBalancerAttributes_CrossZoneLoadBalancing.Enabled = requestLoadBalancerAttributes_loadBalancerAttributes_CrossZoneLoadBalancing_crossZoneLoadBalancing_Enabled.Value;
                requestLoadBalancerAttributes_loadBalancerAttributes_CrossZoneLoadBalancingIsNull   = false;
            }
            // determine if requestLoadBalancerAttributes_loadBalancerAttributes_CrossZoneLoadBalancing should be set to null
            if (requestLoadBalancerAttributes_loadBalancerAttributes_CrossZoneLoadBalancingIsNull)
            {
                requestLoadBalancerAttributes_loadBalancerAttributes_CrossZoneLoadBalancing = null;
            }
            if (requestLoadBalancerAttributes_loadBalancerAttributes_CrossZoneLoadBalancing != null)
            {
                request.LoadBalancerAttributes.CrossZoneLoadBalancing = requestLoadBalancerAttributes_loadBalancerAttributes_CrossZoneLoadBalancing;
                requestLoadBalancerAttributesIsNull = false;
            }
            Amazon.ElasticLoadBalancing.Model.ConnectionDraining requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionDraining = null;

            // populate ConnectionDraining
            var requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionDrainingIsNull = true;

            requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionDraining = new Amazon.ElasticLoadBalancing.Model.ConnectionDraining();
            System.Boolean?requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionDraining_connectionDraining_Enabled = null;
            if (cmdletContext.ConnectionDraining_Enabled != null)
            {
                requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionDraining_connectionDraining_Enabled = cmdletContext.ConnectionDraining_Enabled.Value;
            }
            if (requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionDraining_connectionDraining_Enabled != null)
            {
                requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionDraining.Enabled = requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionDraining_connectionDraining_Enabled.Value;
                requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionDrainingIsNull   = false;
            }
            System.Int32?requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionDraining_connectionDraining_Timeout = null;
            if (cmdletContext.ConnectionDraining_Timeout != null)
            {
                requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionDraining_connectionDraining_Timeout = cmdletContext.ConnectionDraining_Timeout.Value;
            }
            if (requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionDraining_connectionDraining_Timeout != null)
            {
                requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionDraining.Timeout = requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionDraining_connectionDraining_Timeout.Value;
                requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionDrainingIsNull   = false;
            }
            // determine if requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionDraining should be set to null
            if (requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionDrainingIsNull)
            {
                requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionDraining = null;
            }
            if (requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionDraining != null)
            {
                request.LoadBalancerAttributes.ConnectionDraining = requestLoadBalancerAttributes_loadBalancerAttributes_ConnectionDraining;
                requestLoadBalancerAttributesIsNull = false;
            }
            Amazon.ElasticLoadBalancing.Model.AccessLog requestLoadBalancerAttributes_loadBalancerAttributes_AccessLog = null;

            // populate AccessLog
            var requestLoadBalancerAttributes_loadBalancerAttributes_AccessLogIsNull = true;

            requestLoadBalancerAttributes_loadBalancerAttributes_AccessLog = new Amazon.ElasticLoadBalancing.Model.AccessLog();
            System.Int32?requestLoadBalancerAttributes_loadBalancerAttributes_AccessLog_accessLog_EmitInterval = null;
            if (cmdletContext.AccessLog_EmitInterval != null)
            {
                requestLoadBalancerAttributes_loadBalancerAttributes_AccessLog_accessLog_EmitInterval = cmdletContext.AccessLog_EmitInterval.Value;
            }
            if (requestLoadBalancerAttributes_loadBalancerAttributes_AccessLog_accessLog_EmitInterval != null)
            {
                requestLoadBalancerAttributes_loadBalancerAttributes_AccessLog.EmitInterval = requestLoadBalancerAttributes_loadBalancerAttributes_AccessLog_accessLog_EmitInterval.Value;
                requestLoadBalancerAttributes_loadBalancerAttributes_AccessLogIsNull        = false;
            }
            System.Boolean?requestLoadBalancerAttributes_loadBalancerAttributes_AccessLog_accessLog_Enabled = null;
            if (cmdletContext.AccessLog_Enabled != null)
            {
                requestLoadBalancerAttributes_loadBalancerAttributes_AccessLog_accessLog_Enabled = cmdletContext.AccessLog_Enabled.Value;
            }
            if (requestLoadBalancerAttributes_loadBalancerAttributes_AccessLog_accessLog_Enabled != null)
            {
                requestLoadBalancerAttributes_loadBalancerAttributes_AccessLog.Enabled = requestLoadBalancerAttributes_loadBalancerAttributes_AccessLog_accessLog_Enabled.Value;
                requestLoadBalancerAttributes_loadBalancerAttributes_AccessLogIsNull   = false;
            }
            System.String requestLoadBalancerAttributes_loadBalancerAttributes_AccessLog_accessLog_S3BucketName = null;
            if (cmdletContext.AccessLog_S3BucketName != null)
            {
                requestLoadBalancerAttributes_loadBalancerAttributes_AccessLog_accessLog_S3BucketName = cmdletContext.AccessLog_S3BucketName;
            }
            if (requestLoadBalancerAttributes_loadBalancerAttributes_AccessLog_accessLog_S3BucketName != null)
            {
                requestLoadBalancerAttributes_loadBalancerAttributes_AccessLog.S3BucketName = requestLoadBalancerAttributes_loadBalancerAttributes_AccessLog_accessLog_S3BucketName;
                requestLoadBalancerAttributes_loadBalancerAttributes_AccessLogIsNull        = false;
            }
            System.String requestLoadBalancerAttributes_loadBalancerAttributes_AccessLog_accessLog_S3BucketPrefix = null;
            if (cmdletContext.AccessLog_S3BucketPrefix != null)
            {
                requestLoadBalancerAttributes_loadBalancerAttributes_AccessLog_accessLog_S3BucketPrefix = cmdletContext.AccessLog_S3BucketPrefix;
            }
            if (requestLoadBalancerAttributes_loadBalancerAttributes_AccessLog_accessLog_S3BucketPrefix != null)
            {
                requestLoadBalancerAttributes_loadBalancerAttributes_AccessLog.S3BucketPrefix = requestLoadBalancerAttributes_loadBalancerAttributes_AccessLog_accessLog_S3BucketPrefix;
                requestLoadBalancerAttributes_loadBalancerAttributes_AccessLogIsNull          = false;
            }
            // determine if requestLoadBalancerAttributes_loadBalancerAttributes_AccessLog should be set to null
            if (requestLoadBalancerAttributes_loadBalancerAttributes_AccessLogIsNull)
            {
                requestLoadBalancerAttributes_loadBalancerAttributes_AccessLog = null;
            }
            if (requestLoadBalancerAttributes_loadBalancerAttributes_AccessLog != null)
            {
                request.LoadBalancerAttributes.AccessLog = requestLoadBalancerAttributes_loadBalancerAttributes_AccessLog;
                requestLoadBalancerAttributesIsNull      = false;
            }
            // determine if request.LoadBalancerAttributes should be set to null
            if (requestLoadBalancerAttributesIsNull)
            {
                request.LoadBalancerAttributes = null;
            }
            if (cmdletContext.LoadBalancerName != null)
            {
                request.LoadBalancerName = cmdletContext.LoadBalancerName;
            }

            CmdletOutput output;

            // issue call
            var client = Client ?? CreateClient(_CurrentCredentials, _RegionEndpoint);

            try
            {
                var    response       = CallAWSServiceOperation(client, request);
                object pipelineOutput = null;
                pipelineOutput = cmdletContext.Select(response, this);
                output         = new CmdletOutput
                {
                    PipelineOutput  = pipelineOutput,
                    ServiceResponse = response
                };
            }
            catch (Exception e)
            {
                output = new CmdletOutput {
                    ErrorResponse = e
                };
            }

            return(output);
        }
Esempio n. 4
0
 private Amazon.ElasticLoadBalancing.Model.ModifyLoadBalancerAttributesResponse CallAWSServiceOperation(IAmazonElasticLoadBalancing client, Amazon.ElasticLoadBalancing.Model.ModifyLoadBalancerAttributesRequest request)
 {
     Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Elastic Load Balancing", "ModifyLoadBalancerAttributes");
     try
     {
         #if DESKTOP
         return(client.ModifyLoadBalancerAttributes(request));
         #elif CORECLR
         return(client.ModifyLoadBalancerAttributesAsync(request).GetAwaiter().GetResult());
         #else
                 #error "Unknown build edition"
         #endif
     }
     catch (AmazonServiceException exc)
     {
         var webException = exc.InnerException as System.Net.WebException;
         if (webException != null)
         {
             throw new Exception(Utils.Common.FormatNameResolutionFailureMessage(client.Config, webException.Message), webException);
         }
         throw;
     }
 }
        /// <summary>
        /// <para>Modifies the attributes of a specified load balancer.</para>
        /// </summary>
        /// 
        /// <param name="modifyLoadBalancerAttributesRequest">Container for the necessary parameters to execute the ModifyLoadBalancerAttributes service
        /// method on AmazonElasticLoadBalancing.</param>
        /// 
        /// <returns>The response from the ModifyLoadBalancerAttributes service method, as returned by AmazonElasticLoadBalancing.</returns>
        /// 
        /// <exception cref="T:Amazon.ElasticLoadBalancing.Model.InvalidConfigurationRequestException" />
        /// <exception cref="T:Amazon.ElasticLoadBalancing.Model.LoadBalancerAttributeNotFoundException" />
        /// <exception cref="T:Amazon.ElasticLoadBalancing.Model.LoadBalancerNotFoundException" />
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
		public async Task<ModifyLoadBalancerAttributesResponse> ModifyLoadBalancerAttributesAsync(ModifyLoadBalancerAttributesRequest modifyLoadBalancerAttributesRequest, CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new ModifyLoadBalancerAttributesRequestMarshaller();
            var unmarshaller = ModifyLoadBalancerAttributesResponseUnmarshaller.GetInstance();
            var response = await Invoke<IRequest, ModifyLoadBalancerAttributesRequest, ModifyLoadBalancerAttributesResponse>(modifyLoadBalancerAttributesRequest, marshaller, unmarshaller, signer, cancellationToken)
                .ConfigureAwait(continueOnCapturedContext: false);
            return response;
        }
		internal ModifyLoadBalancerAttributesResponse ModifyLoadBalancerAttributes(ModifyLoadBalancerAttributesRequest request)
        {
            var task = ModifyLoadBalancerAttributesAsync(request);
            try
            {
                return task.Result;
            }
            catch(AggregateException e)
            {
                throw e.InnerException;
            }
        }
        /// <summary>
        /// <para>Modifies the attributes of a specified load balancer.</para> <para>You can modify the attributes, such as cross-zone load balancing
        /// and access logs, by either enabling or disabling them.</para> <para>For information on modifying the cross-zone load balancing attribute,
        /// see <a href="http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/enable-disable-crosszone-lb.html">Enable or Disable
        /// Cross-Zone Load Balancing for Your Load balancer</a> in the <i>Elastic Load Balancing Developer Guide</i> .</para> <para>For information on
        /// modifying the access log attribute, see <a href="http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/access-log-collection.html">Enable or Disable Access Log
        /// Collection for Your Load Balancer</a> in the <i>Elastic Load Balancing Developer Guide</i> .</para>
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyLoadBalancerAttributes service
        /// method on AmazonElasticLoadBalancing.</param>
        /// 
        /// <returns>The response from the ModifyLoadBalancerAttributes service method, as returned by AmazonElasticLoadBalancing.</returns>
        /// 
        /// <exception cref="T:Amazon.ElasticLoadBalancing.Model.InvalidConfigurationRequestException" />
        /// <exception cref="T:Amazon.ElasticLoadBalancing.Model.LoadBalancerAttributeNotFoundException" />
        /// <exception cref="T:Amazon.ElasticLoadBalancing.Model.LoadBalancerNotFoundException" />
		public ModifyLoadBalancerAttributesResponse ModifyLoadBalancerAttributes(ModifyLoadBalancerAttributesRequest request)
        {
            var task = ModifyLoadBalancerAttributesAsync(request);
            try
            {
                return task.Result;
            }
            catch(AggregateException e)
            {
                ExceptionDispatchInfo.Capture(e.InnerException).Throw();
                return null;
            }
        }
        /// <summary>
        /// Initiates the asynchronous execution of the ModifyLoadBalancerAttributes operation.
        /// <seealso cref="Amazon.ElasticLoadBalancing.IAmazonElasticLoadBalancing.ModifyLoadBalancerAttributes"/>
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyLoadBalancerAttributes 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<ModifyLoadBalancerAttributesResponse> ModifyLoadBalancerAttributesAsync(ModifyLoadBalancerAttributesRequest request, CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new ModifyLoadBalancerAttributesRequestMarshaller();
            var unmarshaller = ModifyLoadBalancerAttributesResponseUnmarshaller.GetInstance();
            return Invoke<IRequest, ModifyLoadBalancerAttributesRequest, ModifyLoadBalancerAttributesResponse>(request, marshaller, unmarshaller, signer, cancellationToken);
        }
        IAsyncResult invokeModifyLoadBalancerAttributes(ModifyLoadBalancerAttributesRequest request, AsyncCallback callback, object state, bool synchronized)
        {
            var marshaller = new ModifyLoadBalancerAttributesRequestMarshaller();
            var unmarshaller = ModifyLoadBalancerAttributesResponseUnmarshaller.Instance;

            return Invoke(request, callback, state, synchronized, marshaller, unmarshaller, signer);
        }
 /// <summary>
 /// Initiates the asynchronous execution of the ModifyLoadBalancerAttributes operation.
 /// <seealso cref="Amazon.ElasticLoadBalancing.IAmazonElasticLoadBalancing"/>
 /// </summary>
 /// 
 /// <param name="request">Container for the necessary parameters to execute the ModifyLoadBalancerAttributes 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 EndModifyLoadBalancerAttributes
 ///         operation.</returns>
 public IAsyncResult BeginModifyLoadBalancerAttributes(ModifyLoadBalancerAttributesRequest request, AsyncCallback callback, object state)
 {
     return invokeModifyLoadBalancerAttributes(request, callback, state, false);
 }
 /// <summary>
 /// Modifies the attributes of a specified load balancer.
 /// 
 ///  
 /// <para>
 /// You can modify the load balancer attributes, such as <code>AccessLogs</code>, <code>ConnectionDraining</code>,
 /// and <code>CrossZoneLoadBalancing</code> by either enabling or disabling them. Or,
 /// you can modify the load balancer attribute <code>ConnectionSettings</code>, by specifying
 /// an idle connection timeout value for your load balancer.
 /// </para>
 ///  
 /// <para>
 /// For more information, see the following:
 /// </para>
 ///  <ul> <li><a href="http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/TerminologyandKeyConcepts.htmll#request-routing">Cross-Zone
 /// Load Balancing</a></li> <li><a href="http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/TerminologyandKeyConcepts.htmll##conn-drain">Connection
 /// Draining</a></li> <li> <a href="http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/access-log-collection.html">Access
 /// Logs</a>.</li> <li> <a href="http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/TerminologyandKeyConcepts.html#idle-timeout">Connection
 /// Settings</a>.</li> </ul>
 /// </summary>
 /// <param name="request">Container for the necessary parameters to execute the ModifyLoadBalancerAttributes service method.</param>
 /// 
 /// <returns>The response from the ModifyLoadBalancerAttributes service method, as returned by ElasticLoadBalancing.</returns>
 /// <exception cref="AccessPointNotFoundException">
 /// The specified load balancer could not be found.
 /// </exception>
 /// <exception cref="InvalidConfigurationRequestException">
 /// Requested configuration change is invalid.
 /// </exception>
 /// <exception cref="LoadBalancerAttributeNotFoundException">
 /// The specified load balancer attribute could not be found.
 /// </exception>
 public ModifyLoadBalancerAttributesResponse ModifyLoadBalancerAttributes(ModifyLoadBalancerAttributesRequest request)
 {
     IAsyncResult asyncResult = invokeModifyLoadBalancerAttributes(request, null, null, true);
     return EndModifyLoadBalancerAttributes(asyncResult);
 }
        /// <summary>
        /// Initiates the asynchronous execution of the ModifyLoadBalancerAttributes operation.
        /// <seealso cref="Amazon.ElasticLoadBalancing.IAmazonElasticLoadBalancing"/>
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyLoadBalancerAttributes 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 EndModifyLoadBalancerAttributes
        ///         operation.</returns>
        public IAsyncResult BeginModifyLoadBalancerAttributes(ModifyLoadBalancerAttributesRequest request, AsyncCallback callback, object state)
        {
            var marshaller = new ModifyLoadBalancerAttributesRequestMarshaller();
            var unmarshaller = ModifyLoadBalancerAttributesResponseUnmarshaller.Instance;

            return BeginInvoke<ModifyLoadBalancerAttributesRequest>(request, marshaller, unmarshaller,
                callback, state);
        }
 IAsyncResult invokeModifyLoadBalancerAttributes(ModifyLoadBalancerAttributesRequest modifyLoadBalancerAttributesRequest, AsyncCallback callback, object state, bool synchronized)
 {
     IRequest irequest = new ModifyLoadBalancerAttributesRequestMarshaller().Marshall(modifyLoadBalancerAttributesRequest);
     var unmarshaller = ModifyLoadBalancerAttributesResponseUnmarshaller.GetInstance();
     AsyncResult result = new AsyncResult(irequest, callback, state, synchronized, signer, unmarshaller);
     Invoke(result);
     return result;
 }