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 }