Merge pull request #57 from helen-frank/helen-frank/dev-general

fix status

Author: jwcesign

pkg/providers/instance/instance.go

@@ -93,12 +93,12 @@ func (p *DefaultProvider) Create(ctx context.Context, nodeClass *v1alpha1.ECSNod
 		return nil, fmt.Errorf("truncating instance types, %w", err)
 	}
 	tags := getTags(ctx, nodeClass, nodeClaim)
-	launchInstance, err := p.launchInstance(ctx, nodeClass, nodeClaim, instanceTypes, tags)
+	launchInstance, createAutoProvisioningGroupRequest, err := p.launchInstance(ctx, nodeClass, nodeClaim, instanceTypes, tags)
 	if err != nil {
 		return nil, err
 	}
 
-	return p.Get(ctx, *launchInstance.InstanceIds.InstanceId[0])
+	return NewInstanceFromProvisioningGroup(launchInstance, createAutoProvisioningGroupRequest, p.region), nil
 }
 
 func (p *DefaultProvider) Get(ctx context.Context, id string) (*Instance, error) {
@@ -323,28 +323,28 @@ func getTags(ctx context.Context, nodeClass *v1alpha1.ECSNodeClass, nodeClaim *k
 }
 
 func (p *DefaultProvider) launchInstance(ctx context.Context, nodeClass *v1alpha1.ECSNodeClass, nodeClaim *karpv1.NodeClaim, instanceTypes []*cloudprovider.InstanceType,
-	tags map[string]string) (*ecsclient.CreateAutoProvisioningGroupResponseBodyLaunchResultsLaunchResult, error) {
+	tags map[string]string) (*ecsclient.CreateAutoProvisioningGroupResponseBodyLaunchResultsLaunchResult, *ecsclient.CreateAutoProvisioningGroupRequest, error) {
 	if err := p.checkODFallback(nodeClaim, instanceTypes); err != nil {
 		log.FromContext(ctx).Error(err, "failed while checking on-demand fallback")
 	}
 	capacityType := p.getCapacityType(nodeClaim, instanceTypes)
 	zonalVSwitchs, err := p.vSwitchProvider.ZonalVSwitchesForLaunch(ctx, nodeClass, instanceTypes, capacityType)
 	if err != nil {
-		return nil, fmt.Errorf("getting vSwitches, %w", err)
+		return nil, nil, fmt.Errorf("getting vSwitches, %w", err)
 	}
 
 	createAutoProvisioningGroupRequest, err := p.getProvisioningGroup(ctx, nodeClass, nodeClaim, instanceTypes, zonalVSwitchs, capacityType, tags)
 	if err != nil {
-		return nil, fmt.Errorf("getting provisioning group, %w", err)
+		return nil, nil, fmt.Errorf("getting provisioning group, %w", err)
 	}
 
 	runtime := &util.RuntimeOptions{}
 	resp, err := p.ecsClient.CreateAutoProvisioningGroupWithOptions(createAutoProvisioningGroupRequest, runtime)
 	if err != nil {
-		return nil, fmt.Errorf("creating auto provisioning group, %w", err)
+		return nil, nil, fmt.Errorf("creating auto provisioning group, %w", err)
 	}
 
-	return resp.Body.LaunchResults.LaunchResult[0], nil
+	return resp.Body.LaunchResults.LaunchResult[0], createAutoProvisioningGroupRequest, nil
 }
 
 // getCapacityType selects spot if both constraints are flexible and there is an
@@ -401,6 +401,14 @@ func (p *DefaultProvider) getProvisioningGroup(ctx context.Context, nodeClass *v
 		launchTemplateConfigs = append(launchTemplateConfigs, launchTemplateConfig)
 	}
 
+	reqTags := make([]*ecsclient.CreateAutoProvisioningGroupRequestTag, 0, len(tags))
+	for k, v := range tags {
+		reqTags = append(reqTags, &ecsclient.CreateAutoProvisioningGroupRequestTag{
+			Key:   tea.String(k),
+			Value: tea.String(v),
+		})
+	}
+
 	createAutoProvisioningGroupRequest := &ecsclient.CreateAutoProvisioningGroupRequest{
 		RegionId:                        tea.String(p.region),
 		TotalTargetCapacity:             tea.String("1"),
@@ -420,6 +428,7 @@ func (p *DefaultProvider) getProvisioningGroup(ctx context.Context, nodeClass *v
 		SystemDiskConfig: []*ecsclient.CreateAutoProvisioningGroupRequestSystemDiskConfig{
 			{DiskCategory: launchtemplate.SystemDisk.Category},
 		},
+		Tag: reqTags,
 	}
 
 	if capacityType == karpv1.CapacityTypeSpot {

pkg/providers/instance/types.go

@@ -72,6 +72,37 @@ func NewInstance(out *ecsclient.DescribeInstancesResponseBodyInstancesInstance)
 	}
 }
 
+func NewInstanceFromProvisioningGroup(out *ecsclient.CreateAutoProvisioningGroupResponseBodyLaunchResultsLaunchResult,
+	req *ecsclient.CreateAutoProvisioningGroupRequest, region string) *Instance {
+
+	var securityGroupIDs []string
+	if len(req.LaunchConfiguration.SecurityGroupIds) > 0 {
+		securityGroupIDs = lo.Map(req.LaunchConfiguration.SecurityGroupIds, func(securitygroup *string, _ int) string {
+			return *securitygroup
+		})
+	} else {
+		securityGroupIDs = []string{*req.LaunchConfiguration.SecurityGroupId}
+	}
+
+	tags := make(map[string]string, len(req.Tag))
+	for i := range req.Tag {
+		tags[*req.Tag[i].Key] = *req.Tag[i].Value
+	}
+
+	return &Instance{
+		CreationTime:     time.Now(), // estimate the launch time since we just launched
+		Status:           InstanceStatusPending,
+		ID:               *out.InstanceIds.InstanceId[0],
+		ImageID:          *req.LaunchConfiguration.ImageId,
+		Type:             *out.InstanceType,
+		Region:           region,
+		Zone:             *out.ZoneId,
+		CapacityType:     utils.GetCapacityTypes(*out.SpotStrategy),
+		SecurityGroupIDs: securityGroupIDs,
+		Tags:             tags,
+	}
+}
+
 func toSecurityGroupIDs(securityGroups *ecsclient.DescribeInstancesResponseBodyInstancesInstanceSecurityGroupIds) []string {
 	if securityGroups == nil {
 		return []string{}