private Amazon.CloudWatch.Model.PutMetricAlarmResponse CallAWSServiceOperation(IAmazonCloudWatch client, Amazon.CloudWatch.Model.PutMetricAlarmRequest request) { Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon CloudWatch", "PutMetricAlarm"); try { #if DESKTOP return(client.PutMetricAlarm(request)); #elif CORECLR return(client.PutMetricAlarmAsync(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> /// Creates or updates an alarm and associates it with the specified Amazon CloudWatch /// metric. Optionally, this operation can associate one or more Amazon Simple Notification /// Service resources with the alarm. /// /// /// <para> /// When this operation creates an alarm, the alarm state is immediately set to <code>INSUFFICIENT_DATA</code>. /// The alarm is evaluated and its <code>StateValue</code> is set appropriately. Any actions /// associated with the <code>StateValue</code> is then executed. /// </para> /// </summary> /// <param name="request">Container for the necessary parameters to execute the PutMetricAlarm service method.</param> /// /// <returns>The response from the PutMetricAlarm service method, as returned by CloudWatch.</returns> /// <exception cref="Amazon.CloudWatch.Model.LimitExceededException"> /// The quota for alarms for this customer has already been reached. /// </exception> public PutMetricAlarmResponse PutMetricAlarm(PutMetricAlarmRequest request) { var marshaller = new PutMetricAlarmRequestMarshaller(); var unmarshaller = PutMetricAlarmResponseUnmarshaller.Instance; return Invoke<PutMetricAlarmRequest,PutMetricAlarmResponse>(request, marshaller, unmarshaller); }
/// <summary> /// <para> Creates or updates an alarm and associates it with the specified Amazon CloudWatch metric. Optionally, this operation can associate /// one or more Amazon Simple Notification Service resources with the alarm. </para> <para> When this operation creates an alarm, the alarm /// state is immediately set to <c>INSUFFICIENT_DATA</c> . The alarm is evaluated and its <c>StateValue</c> is set appropriately. Any actions /// associated with the <c>StateValue</c> is then executed. </para> <para><b>NOTE:</b> When updating an existing alarm, its StateValue is left /// unchanged. </para> /// </summary> /// /// <param name="putMetricAlarmRequest">Container for the necessary parameters to execute the PutMetricAlarm service method on /// AmazonCloudWatch.</param> /// /// <exception cref="T:Amazon.CloudWatch.Model.LimitExceededException" /> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> public Task<PutMetricAlarmResponse> PutMetricAlarmAsync(PutMetricAlarmRequest putMetricAlarmRequest, CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new PutMetricAlarmRequestMarshaller(); var unmarshaller = PutMetricAlarmResponseUnmarshaller.GetInstance(); return Invoke<IRequest, PutMetricAlarmRequest, PutMetricAlarmResponse>(putMetricAlarmRequest, marshaller, unmarshaller, signer, cancellationToken); }
public object Execute(ExecutorContext context) { var cmdletContext = context as CmdletContext; // create request var request = new Amazon.CloudWatch.Model.PutMetricAlarmRequest(); if (cmdletContext.ActionsEnabled != null) { request.ActionsEnabled = cmdletContext.ActionsEnabled.Value; } if (cmdletContext.AlarmAction != null) { request.AlarmActions = cmdletContext.AlarmAction; } if (cmdletContext.AlarmDescription != null) { request.AlarmDescription = cmdletContext.AlarmDescription; } if (cmdletContext.AlarmName != null) { request.AlarmName = cmdletContext.AlarmName; } if (cmdletContext.ComparisonOperator != null) { request.ComparisonOperator = cmdletContext.ComparisonOperator; } if (cmdletContext.DatapointsToAlarm != null) { request.DatapointsToAlarm = cmdletContext.DatapointsToAlarm.Value; } if (cmdletContext.Dimension != null) { request.Dimensions = cmdletContext.Dimension; } if (cmdletContext.EvaluateLowSampleCountPercentile != null) { request.EvaluateLowSampleCountPercentile = cmdletContext.EvaluateLowSampleCountPercentile; } if (cmdletContext.EvaluationPeriod != null) { request.EvaluationPeriods = cmdletContext.EvaluationPeriod.Value; } if (cmdletContext.ExtendedStatistic != null) { request.ExtendedStatistic = cmdletContext.ExtendedStatistic; } if (cmdletContext.InsufficientDataAction != null) { request.InsufficientDataActions = cmdletContext.InsufficientDataAction; } if (cmdletContext.MetricName != null) { request.MetricName = cmdletContext.MetricName; } if (cmdletContext.Metric != null) { request.Metrics = cmdletContext.Metric; } if (cmdletContext.Namespace != null) { request.Namespace = cmdletContext.Namespace; } if (cmdletContext.OKAction != null) { request.OKActions = cmdletContext.OKAction; } if (cmdletContext.Period != null) { request.Period = cmdletContext.Period.Value; } if (cmdletContext.Statistic != null) { request.Statistic = cmdletContext.Statistic; } if (cmdletContext.Tag != null) { request.Tags = cmdletContext.Tag; } if (cmdletContext.Threshold != null) { request.Threshold = cmdletContext.Threshold.Value; } if (cmdletContext.ThresholdMetricId != null) { request.ThresholdMetricId = cmdletContext.ThresholdMetricId; } if (cmdletContext.TreatMissingData != null) { request.TreatMissingData = cmdletContext.TreatMissingData; } if (cmdletContext.Unit != null) { request.Unit = cmdletContext.Unit; } 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); }
/// <summary> /// <para> Creates or updates an alarm and associates it with the specified Amazon CloudWatch metric. Optionally, this operation can associate /// one or more Amazon Simple Notification Service resources with the alarm. </para> <para> When this operation creates an alarm, the alarm /// state is immediately set to <c>INSUFFICIENT_DATA</c> . The alarm is evaluated and its <c>StateValue</c> is set appropriately. Any actions /// associated with the <c>StateValue</c> is then executed. </para> <para><b>NOTE:</b> When updating an existing alarm, its StateValue is left /// unchanged. </para> /// </summary> /// /// <param name="putMetricAlarmRequest">Container for the necessary parameters to execute the PutMetricAlarm service method on /// AmazonCloudWatch.</param> /// /// <exception cref="T:Amazon.CloudWatch.Model.LimitExceededException" /> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> public async Task<PutMetricAlarmResponse> PutMetricAlarmAsync(PutMetricAlarmRequest putMetricAlarmRequest, CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new PutMetricAlarmRequestMarshaller(); var unmarshaller = PutMetricAlarmResponseUnmarshaller.GetInstance(); var response = await Invoke<IRequest, PutMetricAlarmRequest, PutMetricAlarmResponse>(putMetricAlarmRequest, marshaller, unmarshaller, signer, cancellationToken) .ConfigureAwait(continueOnCapturedContext: false); return response; }
internal PutMetricAlarmResponse PutMetricAlarm(PutMetricAlarmRequest request) { var task = PutMetricAlarmAsync(request); try { return task.Result; } catch(AggregateException e) { throw e.InnerException; } }
/// two weeks, whether or not you delete the alarm. </para> /// </summary> /// /// <param name="describeAlarmHistoryRequest">Container for the necessary parameters to execute the DescribeAlarmHistory service method on /// AmazonCloudWatch.</param> /// /// <returns>The response from the DescribeAlarmHistory service method, as returned by AmazonCloudWatch.</returns> /// /// <exception cref="InvalidNextTokenException"/> public DescribeAlarmHistoryResponse DescribeAlarmHistory(DescribeAlarmHistoryRequest describeAlarmHistoryRequest) { IAsyncResult asyncResult = invokeDescribeAlarmHistory(describeAlarmHistoryRequest, null, null, true); return EndDescribeAlarmHistory(asyncResult); }
private void CreatePhysicalMemoryUtlizationAlarm() { var dimensions = new List<Dimension> { new Dimension() .WithName("InstanceId") .WithValue(_instanceId) }; var putMetricAlarmReq = new PutMetricAlarmRequest { ActionsEnabled = true, AlarmActions = _amazonSnsTopics, AlarmDescription = "Physical memory utilization alarm", AlarmName = _instanceName + "-physical-memory", ComparisonOperator = "GreaterThanOrEqualToThreshold", Dimensions = dimensions, EvaluationPeriods = 1, MetricName = "PhysicalMemoryUtilization", Namespace = "System/Windows", Period = 60*5, Statistic = "Average", Threshold = 85, Unit = "Percent" }; RegionEndpoint regionEndpoint = RegionEndpoint.GetBySystemName(_region); AmazonCloudWatch cloudwatchClient = AWSClientFactory.CreateAmazonCloudWatchClient(regionEndpoint); cloudwatchClient.PutMetricAlarm(putMetricAlarmReq); }
internal PutMetricAlarmResponse PutMetricAlarm(PutMetricAlarmRequest request) { var task = PutMetricAlarmAsync(request); try { return task.Result; } catch(AggregateException e) { ExceptionDispatchInfo.Capture(e.InnerException).Throw(); return null; } }
/// <exception cref="InvalidParameterValueException"/> public ListMetricsResponse ListMetrics(ListMetricsRequest listMetricsRequest) { IAsyncResult asyncResult = invokeListMetrics(listMetricsRequest, null, null, true); return EndListMetrics(asyncResult); } /// <summary> /// Initiates the asynchronous execution of the ListMetrics operation. /// <seealso cref="Amazon.CloudWatch.AmazonCloudWatch.ListMetrics"/> /// </summary> ///
/// <summary> /// Initiates the asynchronous execution of the PutMetricAlarm operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the PutMetricAlarm 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<PutMetricAlarmResponse> PutMetricAlarmAsync(PutMetricAlarmRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new PutMetricAlarmRequestMarshaller(); var unmarshaller = PutMetricAlarmResponseUnmarshaller.Instance; return InvokeAsync<PutMetricAlarmRequest,PutMetricAlarmResponse>(request, marshaller, unmarshaller, cancellationToken); }
public static void CWPutMetricAlarm() { #region CWPutMetricAlarm var client = new AmazonCloudWatchClient(); var dimension = new Dimension { Name = "Desktop Machine Metrics", Value = "Virtual Desktop Machine Usage" }; var request = new PutMetricAlarmRequest { ActionsEnabled = true, AlarmActions = new List<string>() { "arn:aws:sns:us-east-1:80398EXAMPLE:CodingTestResults" }, AlarmDescription = "Too many instances offline", AlarmName = "Offline Instances", ComparisonOperator = ComparisonOperator.GreaterThanOrEqualToThreshold, Dimensions = new List<Dimension>() { dimension }, EvaluationPeriods = 1, MetricName = "Desktop Machines Offline", Namespace = "Example.com Custom Metrics", Period = (int)TimeSpan.FromMinutes(5).TotalSeconds, Statistic = new Statistic("Maximum"), Threshold = 5, Unit = StandardUnit.Count }; client.PutMetricAlarm(request); #endregion }
private void CreateStatusCheckAlarm() { var dimensions = new List<Dimension> { new Dimension() .WithName("InstanceId") .WithValue(_instanceId) }; var putMetricAlarmReq = new PutMetricAlarmRequest { ActionsEnabled = true, AlarmActions = _amazonSnsTopics, AlarmDescription = "Status check alarm", AlarmName = _instanceName + "-status-check", ComparisonOperator = "GreaterThanOrEqualToThreshold", Dimensions = dimensions, EvaluationPeriods = 1, MetricName = "StatusCheckFailed", Namespace = "AWS/EC2", Period = 60*5, Statistic = "Average", Threshold = 1, Unit = "Count" }; RegionEndpoint regionEndpoint = RegionEndpoint.GetBySystemName(_region); AmazonCloudWatch cloudwatchClient = AWSClientFactory.CreateAmazonCloudWatchClient(regionEndpoint); cloudwatchClient.PutMetricAlarm(putMetricAlarmReq); }
/// <summary> /// Initiates the asynchronous execution of the PutMetricAlarm operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the PutMetricAlarm operation on AmazonCloudWatchClient.</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 EndPutMetricAlarm /// operation.</returns> public IAsyncResult BeginPutMetricAlarm(PutMetricAlarmRequest request, AsyncCallback callback, object state) { var marshaller = new PutMetricAlarmRequestMarshaller(); var unmarshaller = PutMetricAlarmResponseUnmarshaller.Instance; return BeginInvoke<PutMetricAlarmRequest>(request, marshaller, unmarshaller, callback, state); }
} #endregion #region DeleteAlarms
/// <summary> /// <para> Creates or updates an alarm and associates it with the /// specified Amazon CloudWatch metric. Optionally, this operation can /// associate one or more Amazon Simple Notification Service resources /// with the alarm. </para> <para> When this operation creates an alarm, /// the alarm state is immediately set to <c>INSUFFICIENT_DATA</c> . The /// alarm is evaluated and its <c>StateValue</c> is set appropriately. /// Any actions associated with the <c>StateValue</c> is then executed. /// </para> <para><b>NOTE:</b> When updating an existing alarm, its /// StateValue is left unchanged. </para> /// </summary> /// /// <param name="putMetricAlarmRequest">Container for the necessary /// parameters to execute the PutMetricAlarm service method on /// AmazonCloudWatch.</param> /// /// <exception cref="LimitExceededException"/> public PutMetricAlarmResponse PutMetricAlarm(PutMetricAlarmRequest putMetricAlarmRequest) { IRequest<PutMetricAlarmRequest> request = new PutMetricAlarmRequestMarshaller().Marshall(putMetricAlarmRequest); PutMetricAlarmResponse response = Invoke<PutMetricAlarmRequest, PutMetricAlarmResponse> (request, this.signer, PutMetricAlarmResponseUnmarshaller.GetInstance()); return response; }
private void CreateDriveUtilizationAlarm(string driveName) { var dimensions = new List<Dimension> { new Dimension { Name = "InstanceId", Value = _instanceId }, new Dimension { Name = "Drive", Value = driveName } }; var putMetricAlarmReq = new PutMetricAlarmRequest { ActionsEnabled = true, AlarmActions = _amazonSnsTopics, AlarmDescription = "Disk space utilization alarm", AlarmName = _instanceName + "-disk-space-" + driveName, ComparisonOperator = "GreaterThanOrEqualToThreshold", Dimensions = dimensions, EvaluationPeriods = 1, MetricName = "DiskSpaceUtilization", Namespace = "System/Windows", Period = 60*5, Statistic = "Average", Threshold = 85, Unit = "Percent" }; RegionEndpoint regionEndpoint = RegionEndpoint.GetBySystemName(_region); AmazonCloudWatch cloudwatchClient = AWSClientFactory.CreateAmazonCloudWatchClient(regionEndpoint); cloudwatchClient.PutMetricAlarm(putMetricAlarmReq); }