func TestCpuStatsSetNotSetToInfinity(t *testing.T) {
// timestamps will be used to simulate +Inf CPU Usage
// timestamps[0] = timestamps[1]
timestamps := []time.Time{
parseNanoTime("2015-02-12T21:22:05.131117533Z"),
parseNanoTime("2015-02-12T21:22:05.131117533Z"),
parseNanoTime("2015-02-12T21:22:05.333776335Z"),
}
cpuTimes := []uint64{
22400432,
116499979,
248503503,
}
memoryUtilizationInBytes := []uint64{
3649536,
3649536,
3649536,
}
// Create and add container stats
queueLength := 3
queue := NewQueue(queueLength)
for i, time := range timestamps {
queue.Add(&ContainerStats{cpuUsage: cpuTimes[i], memoryUsage: memoryUtilizationInBytes[i], timestamp: time})
}
cpuStatsSet, err := queue.GetCPUStatsSet()
if err != nil {
t.Errorf("Error getting cpu stats set: %v", err)
}
// Compute expected usage by using the 1st and 2nd data point in the input queue
// queue.Add should have ignored the 0th item as it has the same timestamp as the
// 1st item
expectedCpuUsage := 100 * float32(cpuTimes[2]-cpuTimes[1]) / float32(timestamps[2].Nanosecond()-timestamps[1].Nanosecond())
max := float32(aws.Float64Value(cpuStatsSet.Max))
if max != expectedCpuUsage {
t.Errorf("Computed cpuStatsSet.Max (%f) != expected value (%f)", max, expectedCpuUsage)
}
sum := float32(aws.Float64Value(cpuStatsSet.Sum))
if sum != expectedCpuUsage {
t.Errorf("Computed cpuStatsSet.Sum (%f) != expected value (%f)", sum, expectedCpuUsage)
}
min := float32(aws.Float64Value(cpuStatsSet.Min))
if min != expectedCpuUsage {
t.Errorf("Computed cpuStatsSet.Min (%f) != expected value (%f)", min, expectedCpuUsage)
}
// Expected sample count is 1 and not 2 as one data point would be discarded on
// account of invalid timestamp
sampleCount := aws.Int64Value(cpuStatsSet.SampleCount)
if sampleCount != 1 {
t.Errorf("Computed cpuStatsSet.SampleCount (%d) != expected value (%d)", sampleCount, 1)
}
}
func launchSpecToMap(
l *ec2.SpotFleetLaunchSpecification,
rootDevName *string,
) map[string]interface{} {
m := make(map[string]interface{})
m["root_block_device"] = rootBlockDeviceToSet(l.BlockDeviceMappings, rootDevName)
m["ebs_block_device"] = ebsBlockDevicesToSet(l.BlockDeviceMappings, rootDevName)
m["ephemeral_block_device"] = ephemeralBlockDevicesToSet(l.BlockDeviceMappings)
if l.ImageId != nil {
m["ami"] = aws.StringValue(l.ImageId)
}
if l.InstanceType != nil {
m["instance_type"] = aws.StringValue(l.InstanceType)
}
if l.SpotPrice != nil {
m["spot_price"] = aws.StringValue(l.SpotPrice)
}
if l.EbsOptimized != nil {
m["ebs_optimized"] = aws.BoolValue(l.EbsOptimized)
}
if l.Monitoring != nil && l.Monitoring.Enabled != nil {
m["monitoring"] = aws.BoolValue(l.Monitoring.Enabled)
}
if l.IamInstanceProfile != nil && l.IamInstanceProfile.Name != nil {
m["iam_instance_profile"] = aws.StringValue(l.IamInstanceProfile.Name)
}
if l.UserData != nil {
ud_dec, err := base64.StdEncoding.DecodeString(aws.StringValue(l.UserData))
if err == nil {
m["user_data"] = string(ud_dec)
}
}
if l.KeyName != nil {
m["key_name"] = aws.StringValue(l.KeyName)
}
if l.Placement != nil {
m["availability_zone"] = aws.StringValue(l.Placement.AvailabilityZone)
}
if l.SubnetId != nil {
m["subnet_id"] = aws.StringValue(l.SubnetId)
}
if l.WeightedCapacity != nil {
m["weighted_capacity"] = fmt.Sprintf("%.3f", aws.Float64Value(l.WeightedCapacity))
}
// m["security_groups"] = securityGroupsToSet(l.SecutiryGroups)
return m
}
// Marshal parses the response from the aws sdk into an awsm Alarm
func (a *Alarm) Marshal(alarm *cloudwatch.MetricAlarm, region string) {
var dimensions []string
var operator string
for _, dim := range alarm.Dimensions {
dimensions = append(dimensions, aws.StringValue(dim.Name)+" = "+aws.StringValue(dim.Value))
}
switch aws.StringValue(alarm.ComparisonOperator) {
case "GreaterThanThreshold":
operator = ">"
case "GreaterThanOrEqualToThreshold":
operator = ">="
case "LessThanThreshold":
operator = "<"
case "LessThanOrEqualToThreshold":
operator = "<="
}
var actionArns []string
var actionNames []string
for _, action := range alarm.AlarmActions {
arnStr := aws.StringValue(action)
actionArns = append(actionArns, arnStr)
arn, err := ParseArn(arnStr)
if err == nil {
actionNames = append(actionNames, arn.PolicyName)
} else {
actionNames = append(actionNames, "??????")
}
}
a.Name = aws.StringValue(alarm.AlarmName)
a.Arn = aws.StringValue(alarm.AlarmArn)
a.Description = aws.StringValue(alarm.AlarmDescription)
a.State = aws.StringValue(alarm.StateValue)
a.Trigger = fmt.Sprintf("%s %s %d (%s)", aws.StringValue(alarm.MetricName), operator, int(aws.Float64Value(alarm.Threshold)), aws.StringValue(alarm.Statistic))
a.Period = fmt.Sprint(aws.Int64Value(alarm.Period))
a.EvalPeriods = fmt.Sprint(aws.Int64Value(alarm.EvaluationPeriods))
a.ActionArns = actionArns
a.ActionNames = strings.Join(actionNames, ", ")
a.Dimensions = strings.Join(dimensions, ", ")
a.Namespace = aws.StringValue(alarm.Namespace)
a.Region = region
}