mirror of
https://github.com/mulgadc/spinifex.git
synced 2026-10-20 19:25:52 +00:00
refactor(daemon): collapse one-line NATS handler wrappers into the subscription table (#557)
This commit is contained in:
Julian Sommer
+243
-241
@@ -770,123 +770,125 @@ func (d *Daemon) subscribeAll() error {
|
||||
subs := []natsSub{
|
||||
// ec2.RunInstances is handled by dynamic per-instance-type subscriptions
|
||||
// managed by ResourceManager.initSubscriptions()
|
||||
{"ec2.CreateKeyPair", d.handleEC2CreateKeyPair, "spinifex-workers"},
|
||||
{"ec2.DeleteKeyPair", d.handleEC2DeleteKeyPair, "spinifex-workers"},
|
||||
{"ec2.DescribeKeyPairs", d.handleEC2DescribeKeyPairs, "spinifex-workers"},
|
||||
{"ec2.ImportKeyPair", d.handleEC2ImportKeyPair, "spinifex-workers"},
|
||||
{"ec2.CreateKeyPair", handleNATSRequest(d.keyService.CreateKeyPair), "spinifex-workers"},
|
||||
{"ec2.DeleteKeyPair", handleNATSRequest(d.keyService.DeleteKeyPair), "spinifex-workers"},
|
||||
{"ec2.DescribeKeyPairs", handleNATSRequest(d.keyService.DescribeKeyPairs), "spinifex-workers"},
|
||||
{"ec2.ImportKeyPair", handleNATSRequest(d.keyService.ImportKeyPair), "spinifex-workers"},
|
||||
{"imds.ec2.get_public_key", d.handleIMDSGetPublicKey, "spinifex-workers"},
|
||||
{"ec2.DescribeImages", d.handleEC2DescribeImages, "spinifex-workers"},
|
||||
{"ec2.DescribeImages", handleNATSRequest(d.imageService.DescribeImages), "spinifex-workers"},
|
||||
{"ec2.CreateImage", d.handleEC2CreateImage, ""},
|
||||
{"ec2.DeregisterImage", d.handleEC2DeregisterImage, "spinifex-workers"},
|
||||
{"ec2.RegisterImage", d.handleEC2RegisterImage, "spinifex-workers"},
|
||||
{"ec2.CopyImage", d.handleEC2CopyImage, "spinifex-workers"},
|
||||
{"ec2.DescribeImageAttribute", d.handleEC2DescribeImageAttribute, "spinifex-workers"},
|
||||
{"ec2.ModifyImageAttribute", d.handleEC2ModifyImageAttribute, "spinifex-workers"},
|
||||
{"ec2.ResetImageAttribute", d.handleEC2ResetImageAttribute, "spinifex-workers"},
|
||||
{"ec2.CreateVolume", d.handleEC2CreateVolume, "spinifex-workers"},
|
||||
{"ec2.DescribeVolumes", d.handleEC2DescribeVolumes, "spinifex-workers"},
|
||||
{"ec2.DeregisterImage", handleNATSRequest(d.imageService.DeregisterImage), "spinifex-workers"},
|
||||
{"ec2.RegisterImage", handleNATSRequest(d.imageService.RegisterImage), "spinifex-workers"},
|
||||
{"ec2.CopyImage", handleNATSRequest(d.imageService.CopyImage), "spinifex-workers"},
|
||||
{"ec2.DescribeImageAttribute", handleNATSRequest(d.imageService.DescribeImageAttribute), "spinifex-workers"},
|
||||
{"ec2.ModifyImageAttribute", handleNATSRequest(d.imageService.ModifyImageAttribute), "spinifex-workers"},
|
||||
{"ec2.ResetImageAttribute", handleNATSRequest(d.imageService.ResetImageAttribute), "spinifex-workers"},
|
||||
{"ec2.CreateVolume", handleNATSRequest(d.volumeService.CreateVolume), "spinifex-workers"},
|
||||
{"ec2.DescribeVolumes", handleNATSRequest(d.volumeService.DescribeVolumes), "spinifex-workers"},
|
||||
{"ec2.ModifyVolume", d.handleEC2ModifyVolume, "spinifex-workers"},
|
||||
{"ec2.DeleteVolume", d.handleEC2DeleteVolume, "spinifex-workers"},
|
||||
{"ec2.DescribeVolumeStatus", d.handleEC2DescribeVolumeStatus, "spinifex-workers"},
|
||||
{"ec2.DescribeVolumesModifications", d.handleEC2DescribeVolumesModifications, "spinifex-workers"},
|
||||
{"ec2.CreateSnapshot", d.handleEC2CreateSnapshot, "spinifex-workers"},
|
||||
{"ec2.DescribeSnapshots", d.handleEC2DescribeSnapshots, "spinifex-workers"},
|
||||
{"ec2.DeleteSnapshot", d.handleEC2DeleteSnapshot, "spinifex-workers"},
|
||||
{"ec2.CopySnapshot", d.handleEC2CopySnapshot, "spinifex-workers"},
|
||||
{"ec2.CreateTags", d.handleEC2CreateTags, "spinifex-workers"},
|
||||
{"ec2.DeleteTags", d.handleEC2DeleteTags, "spinifex-workers"},
|
||||
{"ec2.DescribeTags", d.handleEC2DescribeTags, "spinifex-workers"},
|
||||
{"ec2.CreateEgressOnlyInternetGateway", d.handleEC2CreateEgressOnlyInternetGateway, "spinifex-workers"},
|
||||
{"ec2.DeleteEgressOnlyInternetGateway", d.handleEC2DeleteEgressOnlyInternetGateway, "spinifex-workers"},
|
||||
{"ec2.DescribeEgressOnlyInternetGateways", d.handleEC2DescribeEgressOnlyInternetGateways, "spinifex-workers"},
|
||||
{"ec2.CreateInternetGateway", d.handleEC2CreateInternetGateway, "spinifex-workers"},
|
||||
{"ec2.DeleteInternetGateway", d.handleEC2DeleteInternetGateway, "spinifex-workers"},
|
||||
{"ec2.DescribeInternetGateways", d.handleEC2DescribeInternetGateways, "spinifex-workers"},
|
||||
{"ec2.AttachInternetGateway", d.handleEC2AttachInternetGateway, "spinifex-workers"},
|
||||
{"ec2.DetachInternetGateway", d.handleEC2DetachInternetGateway, "spinifex-workers"},
|
||||
{"ec2.CreatePlacementGroup", d.handleEC2CreatePlacementGroup, "spinifex-workers"},
|
||||
{"ec2.DeletePlacementGroup", d.handleEC2DeletePlacementGroup, "spinifex-workers"},
|
||||
{"ec2.DescribePlacementGroups", d.handleEC2DescribePlacementGroups, "spinifex-workers"},
|
||||
{"ec2.ReserveSpreadNodes", d.handleEC2ReserveSpreadNodes, "spinifex-workers"},
|
||||
{"ec2.FinalizeSpreadInstances", d.handleEC2FinalizeSpreadInstances, "spinifex-workers"},
|
||||
{"ec2.ReleaseSpreadNodes", d.handleEC2ReleaseSpreadNodes, "spinifex-workers"},
|
||||
{"ec2.RemoveInstanceFromPlacementGroup", d.handleEC2RemoveInstanceFromPlacementGroup, "spinifex-workers"},
|
||||
{"ec2.ReserveClusterNode", d.handleEC2ReserveClusterNode, "spinifex-workers"},
|
||||
{"ec2.FinalizeClusterInstances", d.handleEC2FinalizeClusterInstances, "spinifex-workers"},
|
||||
{"ec2.CreateLaunchTemplate", d.handleEC2CreateLaunchTemplate, "spinifex-workers"},
|
||||
{"ec2.CreateLaunchTemplateVersion", d.handleEC2CreateLaunchTemplateVersion, "spinifex-workers"},
|
||||
{"ec2.DeleteLaunchTemplate", d.handleEC2DeleteLaunchTemplate, "spinifex-workers"},
|
||||
{"ec2.DeleteLaunchTemplateVersions", d.handleEC2DeleteLaunchTemplateVersions, "spinifex-workers"},
|
||||
{"ec2.ModifyLaunchTemplate", d.handleEC2ModifyLaunchTemplate, "spinifex-workers"},
|
||||
{"ec2.DescribeLaunchTemplates", d.handleEC2DescribeLaunchTemplates, "spinifex-workers"},
|
||||
{"ec2.DescribeLaunchTemplateVersions", d.handleEC2DescribeLaunchTemplateVersions, "spinifex-workers"},
|
||||
{"ec2.PutSpotInstanceRequests", d.handleEC2PutSpotInstanceRequests, "spinifex-workers"},
|
||||
{"ec2.DescribeSpotInstanceRequests", d.handleEC2DescribeSpotInstanceRequests, "spinifex-workers"},
|
||||
{"ec2.CancelSpotInstanceRequests", d.handleEC2CancelSpotInstanceRequests, "spinifex-workers"},
|
||||
{"ec2.DeleteVolume", handleNATSRequest(d.volumeService.DeleteVolume), "spinifex-workers"},
|
||||
{"ec2.DescribeVolumeStatus", handleNATSRequest(d.volumeService.DescribeVolumeStatus), "spinifex-workers"},
|
||||
{"ec2.DescribeVolumesModifications", handleNATSRequest(d.volumeService.DescribeVolumesModifications), "spinifex-workers"},
|
||||
{"ec2.CreateSnapshot", handleNATSRequest(d.snapshotService.CreateSnapshot), "spinifex-workers"},
|
||||
{"ec2.DescribeSnapshots", handleNATSRequest(d.snapshotService.DescribeSnapshots), "spinifex-workers"},
|
||||
{"ec2.DeleteSnapshot", handleNATSRequest(d.snapshotService.DeleteSnapshot), "spinifex-workers"},
|
||||
{"ec2.CopySnapshot", handleNATSRequest(d.snapshotService.CopySnapshot), "spinifex-workers"},
|
||||
{"ec2.CreateTags", handleNATSRequest(d.createTags), "spinifex-workers"},
|
||||
{"ec2.DeleteTags", handleNATSRequest(d.deleteTags), "spinifex-workers"},
|
||||
{"ec2.DescribeTags", handleNATSRequest(d.tagsService.DescribeTags), "spinifex-workers"},
|
||||
{"ec2.CreateEgressOnlyInternetGateway", handleNATSRequest(d.eigwService.CreateEgressOnlyInternetGateway), "spinifex-workers"},
|
||||
{"ec2.DeleteEgressOnlyInternetGateway", handleNATSRequest(d.eigwService.DeleteEgressOnlyInternetGateway), "spinifex-workers"},
|
||||
{"ec2.DescribeEgressOnlyInternetGateways", handleNATSRequest(d.eigwService.DescribeEgressOnlyInternetGateways), "spinifex-workers"},
|
||||
{"ec2.CreateInternetGateway", handleNATSRequest(d.igwService.CreateInternetGateway), "spinifex-workers"},
|
||||
{"ec2.DeleteInternetGateway", handleNATSRequest(d.igwService.DeleteInternetGateway), "spinifex-workers"},
|
||||
{"ec2.DescribeInternetGateways", handleNATSRequest(d.igwService.DescribeInternetGateways), "spinifex-workers"},
|
||||
{"ec2.AttachInternetGateway", handleNATSRequest(d.igwService.AttachInternetGateway), "spinifex-workers"},
|
||||
{"ec2.DetachInternetGateway", handleNATSRequest(d.igwService.DetachInternetGateway), "spinifex-workers"},
|
||||
{"ec2.CreatePlacementGroup", handleNATSRequest(d.placementGroupService.CreatePlacementGroup), "spinifex-workers"},
|
||||
{"ec2.DeletePlacementGroup", handleNATSRequest(d.placementGroupService.DeletePlacementGroup), "spinifex-workers"},
|
||||
{"ec2.DescribePlacementGroups", handleNATSRequest(d.placementGroupService.DescribePlacementGroups), "spinifex-workers"},
|
||||
{"ec2.ReserveSpreadNodes", handleNATSRequest(d.placementGroupService.ReserveSpreadNodes), "spinifex-workers"},
|
||||
{"ec2.FinalizeSpreadInstances", handleNATSRequest(d.placementGroupService.FinalizeSpreadInstances), "spinifex-workers"},
|
||||
{"ec2.ReleaseSpreadNodes", handleNATSRequest(d.placementGroupService.ReleaseSpreadNodes), "spinifex-workers"},
|
||||
{"ec2.RemoveInstanceFromPlacementGroup", handleNATSRequest(d.placementGroupService.RemoveInstance), "spinifex-workers"},
|
||||
{"ec2.ReserveClusterNode", handleNATSRequest(d.placementGroupService.ReserveClusterNode), "spinifex-workers"},
|
||||
{"ec2.FinalizeClusterInstances", handleNATSRequest(d.placementGroupService.FinalizeClusterInstances), "spinifex-workers"},
|
||||
{"ec2.CreateLaunchTemplate", handleNATSRequest(d.launchTemplateService.CreateLaunchTemplate), "spinifex-workers"},
|
||||
{"ec2.CreateLaunchTemplateVersion", handleNATSRequest(d.launchTemplateService.CreateLaunchTemplateVersion), "spinifex-workers"},
|
||||
{"ec2.DeleteLaunchTemplate", handleNATSRequest(d.launchTemplateService.DeleteLaunchTemplate), "spinifex-workers"},
|
||||
{"ec2.DeleteLaunchTemplateVersions", handleNATSRequest(d.launchTemplateService.DeleteLaunchTemplateVersions), "spinifex-workers"},
|
||||
{"ec2.ModifyLaunchTemplate", handleNATSRequest(d.launchTemplateService.ModifyLaunchTemplate), "spinifex-workers"},
|
||||
{"ec2.DescribeLaunchTemplates", handleNATSRequest(d.launchTemplateService.DescribeLaunchTemplates), "spinifex-workers"},
|
||||
{"ec2.DescribeLaunchTemplateVersions", handleNATSRequest(d.launchTemplateService.DescribeLaunchTemplateVersions), "spinifex-workers"},
|
||||
{"ec2.PutSpotInstanceRequests", handleNATSRequest(d.spotInstanceService.PutSpotInstanceRequests), "spinifex-workers"},
|
||||
{"ec2.DescribeSpotInstanceRequests", handleNATSRequest(d.spotInstanceService.DescribeSpotInstanceRequests), "spinifex-workers"},
|
||||
{"ec2.CancelSpotInstanceRequests", handleNATSRequest(d.spotInstanceService.CancelSpotInstanceRequests), "spinifex-workers"},
|
||||
// Capacity reservations: Create is node-targeted (gateway pins one node);
|
||||
// Describe fans out and Cancel broadcasts, so both use plain Subscribe.
|
||||
{fmt.Sprintf("ec2.CreateCapacityReservation.%s", d.node), d.handleEC2CreateCapacityReservation, ""},
|
||||
{"ec2.DescribeCapacityReservations", d.handleEC2DescribeCapacityReservations, ""},
|
||||
{"ec2.CancelCapacityReservation", d.handleEC2CancelCapacityReservation, ""},
|
||||
{"ec2.CreateNatGateway", d.handleEC2CreateNatGateway, "spinifex-workers"},
|
||||
{"ec2.DeleteNatGateway", d.handleEC2DeleteNatGateway, "spinifex-workers"},
|
||||
{"ec2.DescribeNatGateways", d.handleEC2DescribeNatGateways, "spinifex-workers"},
|
||||
{"ec2.CreateRouteTable", d.handleEC2CreateRouteTable, "spinifex-workers"},
|
||||
{"ec2.DeleteRouteTable", d.handleEC2DeleteRouteTable, "spinifex-workers"},
|
||||
{"ec2.DescribeRouteTables", d.handleEC2DescribeRouteTables, "spinifex-workers"},
|
||||
{"ec2.CreateRoute", d.handleEC2CreateRoute, "spinifex-workers"},
|
||||
{"ec2.DeleteRoute", d.handleEC2DeleteRoute, "spinifex-workers"},
|
||||
{"ec2.ReplaceRoute", d.handleEC2ReplaceRoute, "spinifex-workers"},
|
||||
{"ec2.AssociateRouteTable", d.handleEC2AssociateRouteTable, "spinifex-workers"},
|
||||
{"ec2.DisassociateRouteTable", d.handleEC2DisassociateRouteTable, "spinifex-workers"},
|
||||
{"ec2.ReplaceRouteTableAssociation", d.handleEC2ReplaceRouteTableAssociation, "spinifex-workers"},
|
||||
{"ec2.CreateVpc", d.handleEC2CreateVpc, "spinifex-workers"},
|
||||
{"ec2.DeleteVpc", d.handleEC2DeleteVpc, "spinifex-workers"},
|
||||
{"ec2.DescribeVpcs", d.handleEC2DescribeVpcs, "spinifex-workers"},
|
||||
{"ec2.CreateSubnet", d.handleEC2CreateSubnet, "spinifex-workers"},
|
||||
{"ec2.DeleteSubnet", d.handleEC2DeleteSubnet, "spinifex-workers"},
|
||||
{"ec2.DescribeSubnets", d.handleEC2DescribeSubnets, "spinifex-workers"},
|
||||
{"ec2.ModifySubnetAttribute", d.handleEC2ModifySubnetAttribute, "spinifex-workers"},
|
||||
{"ec2.ModifyVpcAttribute", d.handleEC2ModifyVpcAttribute, "spinifex-workers"},
|
||||
{"ec2.DescribeVpcAttribute", d.handleEC2DescribeVpcAttribute, "spinifex-workers"},
|
||||
{"ec2.CreateNetworkInterface", d.handleEC2CreateNetworkInterface, "spinifex-workers"},
|
||||
{"ec2.DeleteNetworkInterface", d.handleEC2DeleteNetworkInterface, "spinifex-workers"},
|
||||
{"ec2.DescribeNetworkInterfaces", d.handleEC2DescribeNetworkInterfaces, "spinifex-workers"},
|
||||
{"ec2.ModifyNetworkInterfaceAttribute", d.handleEC2ModifyNetworkInterfaceAttribute, "spinifex-workers"},
|
||||
{"ec2.CreateSecurityGroup", d.handleEC2CreateSecurityGroup, "spinifex-workers"},
|
||||
{"ec2.DeleteSecurityGroup", d.handleEC2DeleteSecurityGroup, "spinifex-workers"},
|
||||
{"ec2.DescribeSecurityGroups", d.handleEC2DescribeSecurityGroups, "spinifex-workers"},
|
||||
{"ec2.DescribeSecurityGroupRules", d.handleEC2DescribeSecurityGroupRules, "spinifex-workers"},
|
||||
{"ec2.AuthorizeSecurityGroupIngress", d.handleEC2AuthorizeSecurityGroupIngress, "spinifex-workers"},
|
||||
{"ec2.AuthorizeSecurityGroupEgress", d.handleEC2AuthorizeSecurityGroupEgress, "spinifex-workers"},
|
||||
{"ec2.RevokeSecurityGroupIngress", d.handleEC2RevokeSecurityGroupIngress, "spinifex-workers"},
|
||||
{"ec2.RevokeSecurityGroupEgress", d.handleEC2RevokeSecurityGroupEgress, "spinifex-workers"},
|
||||
{"ec2.ModifyInstanceAttribute", d.handleEC2ModifyInstanceAttribute, "spinifex-workers"},
|
||||
{"ec2.ModifyInstanceMetadataOptions", d.handleEC2ModifyInstanceMetadataOptions, "spinifex-workers"},
|
||||
{"ec2.CreateNatGateway", handleNATSRequest(d.natGatewayService.CreateNatGateway), "spinifex-workers"},
|
||||
{"ec2.DeleteNatGateway", handleNATSRequest(d.natGatewayService.DeleteNatGateway), "spinifex-workers"},
|
||||
{"ec2.DescribeNatGateways", handleNATSRequest(d.natGatewayService.DescribeNatGateways), "spinifex-workers"},
|
||||
{"ec2.CreateRouteTable", handleNATSRequest(d.routeTableService.CreateRouteTable), "spinifex-workers"},
|
||||
{"ec2.DeleteRouteTable", handleNATSRequest(d.routeTableService.DeleteRouteTable), "spinifex-workers"},
|
||||
{"ec2.DescribeRouteTables", handleNATSRequest(d.routeTableService.DescribeRouteTables), "spinifex-workers"},
|
||||
{"ec2.CreateRoute", handleNATSRequest(d.routeTableService.CreateRoute), "spinifex-workers"},
|
||||
{"ec2.DeleteRoute", handleNATSRequest(d.routeTableService.DeleteRoute), "spinifex-workers"},
|
||||
{"ec2.ReplaceRoute", handleNATSRequest(d.routeTableService.ReplaceRoute), "spinifex-workers"},
|
||||
{"ec2.AssociateRouteTable", handleNATSRequest(d.routeTableService.AssociateRouteTable), "spinifex-workers"},
|
||||
{"ec2.DisassociateRouteTable", handleNATSRequest(d.routeTableService.DisassociateRouteTable), "spinifex-workers"},
|
||||
{"ec2.ReplaceRouteTableAssociation", handleNATSRequest(d.routeTableService.ReplaceRouteTableAssociation), "spinifex-workers"},
|
||||
{"ec2.CreateVpc", handleNATSRequest(d.vpcService.CreateVpc), "spinifex-workers"},
|
||||
{"ec2.DeleteVpc", handleNATSRequest(d.vpcService.DeleteVpc), "spinifex-workers"},
|
||||
{"ec2.DescribeVpcs", handleNATSRequest(d.vpcService.DescribeVpcs), "spinifex-workers"},
|
||||
{"ec2.CreateSubnet", handleNATSRequest(d.vpcService.CreateSubnet), "spinifex-workers"},
|
||||
{"ec2.DeleteSubnet", handleNATSRequest(d.vpcService.DeleteSubnet), "spinifex-workers"},
|
||||
{"ec2.DescribeSubnets", handleNATSRequest(d.vpcService.DescribeSubnets), "spinifex-workers"},
|
||||
{"ec2.ModifySubnetAttribute", handleNATSRequest(d.vpcService.ModifySubnetAttribute), "spinifex-workers"},
|
||||
{"ec2.ModifyVpcAttribute", handleNATSRequest(d.vpcService.ModifyVpcAttribute), "spinifex-workers"},
|
||||
{"ec2.DescribeVpcAttribute", handleNATSRequest(d.vpcService.DescribeVpcAttribute), "spinifex-workers"},
|
||||
{"ec2.CreateNetworkInterface", handleNATSRequest(d.vpcService.CreateNetworkInterface), "spinifex-workers"},
|
||||
{"ec2.DeleteNetworkInterface", handleNATSRequest(d.vpcService.DeleteNetworkInterface), "spinifex-workers"},
|
||||
{"ec2.DescribeNetworkInterfaces", handleNATSRequest(d.vpcService.DescribeNetworkInterfaces), "spinifex-workers"},
|
||||
{"ec2.ModifyNetworkInterfaceAttribute", handleNATSRequest(d.vpcService.ModifyNetworkInterfaceAttribute), "spinifex-workers"},
|
||||
{"ec2.CreateSecurityGroup", handleNATSRequest(d.vpcService.CreateSecurityGroup), "spinifex-workers"},
|
||||
{"ec2.DeleteSecurityGroup", handleNATSRequest(d.vpcService.DeleteSecurityGroup), "spinifex-workers"},
|
||||
{"ec2.DescribeSecurityGroups", handleNATSRequest(d.vpcService.DescribeSecurityGroups), "spinifex-workers"},
|
||||
{"ec2.DescribeSecurityGroupRules", handleNATSRequest(d.vpcService.DescribeSecurityGroupRules), "spinifex-workers"},
|
||||
{"ec2.AuthorizeSecurityGroupIngress", handleNATSRequest(d.vpcService.AuthorizeSecurityGroupIngress), "spinifex-workers"},
|
||||
{"ec2.AuthorizeSecurityGroupEgress", handleNATSRequest(d.vpcService.AuthorizeSecurityGroupEgress), "spinifex-workers"},
|
||||
{"ec2.RevokeSecurityGroupIngress", handleNATSRequest(d.vpcService.RevokeSecurityGroupIngress), "spinifex-workers"},
|
||||
{"ec2.RevokeSecurityGroupEgress", handleNATSRequest(d.vpcService.RevokeSecurityGroupEgress), "spinifex-workers"},
|
||||
{"ec2.ModifyInstanceAttribute", handleNATSRequest(d.instanceService.ModifyInstanceAttribute), "spinifex-workers"},
|
||||
{"ec2.ModifyInstanceMetadataOptions", handleNATSRequest(d.instanceService.ModifyInstanceMetadataOptions), "spinifex-workers"},
|
||||
{"ec2.start", d.handleEC2StartStoppedInstance, "spinifex-workers"},
|
||||
{fmt.Sprintf("ec2.start.%s", d.node), d.handleEC2StartStoppedInstanceDirect, ""},
|
||||
{"ec2.terminate", d.handleEC2TerminateStoppedInstance, "spinifex-workers"},
|
||||
// ec2.start.{node} is the node-targeted variant: it always starts locally
|
||||
// and never re-forwards, so it goes straight to the service (no routing loop).
|
||||
{fmt.Sprintf("ec2.start.%s", d.node), handleNATSRequest(d.instanceService.StartStoppedInstance), ""},
|
||||
{"ec2.terminate", handleNATSRequest(d.instanceService.TerminateStoppedInstance), "spinifex-workers"},
|
||||
{"ec2.DescribeStoppedInstances", d.handleEC2DescribeStoppedInstances, "spinifex-workers"},
|
||||
{"ec2.DescribeTerminatedInstances", d.handleEC2DescribeTerminatedInstances, "spinifex-workers"},
|
||||
// these fan out to all nodes and gateway aggregates the results. The
|
||||
// handler only sees per-daemon local state (vmMgr/stoppedStore), so
|
||||
// any queue-grouped routing produces 1/N false NotFound responses.
|
||||
{"ec2.DescribeInstances", d.handleEC2DescribeInstances, ""},
|
||||
{"ec2.DescribeInstanceStatus", d.handleEC2DescribeInstanceStatus, ""},
|
||||
{"ec2.DescribeInstanceTypes", d.handleEC2DescribeInstanceTypes, ""},
|
||||
{"ec2.DescribeInstanceAttribute", d.handleEC2DescribeInstanceAttribute, ""},
|
||||
{"ec2.DescribeInstanceStatus", handleNATSRequest(d.instanceService.DescribeInstanceStatus), ""},
|
||||
{"ec2.DescribeInstanceTypes", handleNATSRequest(d.instanceService.DescribeInstanceTypes), ""},
|
||||
{"ec2.DescribeInstanceAttribute", handleNATSRequest(d.instanceService.DescribeInstanceAttribute), ""},
|
||||
// IAM instance profile associations: Disassociate/Replace mutate the
|
||||
// owning daemon's vm.VM (non-owners NoOp with Found=false); Describe
|
||||
// returns per-daemon matches that the gateway concatenates.
|
||||
{"ec2.IamProfileAssociation.disassociate", d.handleIamProfileDisassociate, ""},
|
||||
{"ec2.IamProfileAssociation.replace", d.handleIamProfileReplace, ""},
|
||||
{"ec2.IamProfileAssociation.describe", d.handleIamProfileDescribe, ""},
|
||||
{"ec2.EnableEbsEncryptionByDefault", d.handleEC2EnableEbsEncryptionByDefault, "spinifex-workers"},
|
||||
{"ec2.DisableEbsEncryptionByDefault", d.handleEC2DisableEbsEncryptionByDefault, "spinifex-workers"},
|
||||
{"ec2.GetEbsEncryptionByDefault", d.handleEC2GetEbsEncryptionByDefault, "spinifex-workers"},
|
||||
{"ec2.GetSerialConsoleAccessStatus", d.handleEC2GetSerialConsoleAccessStatus, "spinifex-workers"},
|
||||
{"ec2.EnableSerialConsoleAccess", d.handleEC2EnableSerialConsoleAccess, "spinifex-workers"},
|
||||
{"ec2.DisableSerialConsoleAccess", d.handleEC2DisableSerialConsoleAccess, "spinifex-workers"},
|
||||
{"ec2.IamProfileAssociation.disassociate", handleNATSRequest(d.instanceService.DisassociateIamProfileAssociation), ""},
|
||||
{"ec2.IamProfileAssociation.replace", handleNATSRequest(d.instanceService.ReplaceIamProfileAssociation), ""},
|
||||
{"ec2.IamProfileAssociation.describe", handleNATSRequest(d.instanceService.DescribeIamProfileAssociations), ""},
|
||||
{"ec2.EnableEbsEncryptionByDefault", handleNATSRequest(d.accountService.EnableEbsEncryptionByDefault), "spinifex-workers"},
|
||||
{"ec2.DisableEbsEncryptionByDefault", handleNATSRequest(d.accountService.DisableEbsEncryptionByDefault), "spinifex-workers"},
|
||||
{"ec2.GetEbsEncryptionByDefault", handleNATSRequest(d.accountService.GetEbsEncryptionByDefault), "spinifex-workers"},
|
||||
{"ec2.GetSerialConsoleAccessStatus", handleNATSRequest(d.accountService.GetSerialConsoleAccessStatus), "spinifex-workers"},
|
||||
{"ec2.EnableSerialConsoleAccess", handleNATSRequest(d.accountService.EnableSerialConsoleAccess), "spinifex-workers"},
|
||||
{"ec2.DisableSerialConsoleAccess", handleNATSRequest(d.accountService.DisableSerialConsoleAccess), "spinifex-workers"},
|
||||
{fmt.Sprintf("spinifex.admin.%s.health", d.node), d.handleHealthCheck, ""},
|
||||
{"spinifex.nodes.discover", d.handleNodeDiscover, ""},
|
||||
{"spinifex.node.status", d.handleNodeStatus, ""},
|
||||
@@ -907,41 +909,41 @@ func (d *Daemon) subscribeAll() error {
|
||||
// Without a subscriber the gateway returns nats.ErrNoResponders → ServiceUnavailable.
|
||||
if d.elbv2Service.GatewayURL != "" {
|
||||
subs = append(subs,
|
||||
natsSub{"elbv2.CreateLoadBalancer", d.handleELBv2CreateLoadBalancer, "spinifex-workers"},
|
||||
natsSub{"elbv2.DeleteLoadBalancer", d.handleELBv2DeleteLoadBalancer, "spinifex-workers"},
|
||||
natsSub{"elbv2.DescribeLoadBalancers", d.handleELBv2DescribeLoadBalancers, "spinifex-workers"},
|
||||
natsSub{"elbv2.CreateTargetGroup", d.handleELBv2CreateTargetGroup, "spinifex-workers"},
|
||||
natsSub{"elbv2.ModifyTargetGroup", d.handleELBv2ModifyTargetGroup, "spinifex-workers"},
|
||||
natsSub{"elbv2.DeleteTargetGroup", d.handleELBv2DeleteTargetGroup, "spinifex-workers"},
|
||||
natsSub{"elbv2.DescribeTargetGroups", d.handleELBv2DescribeTargetGroups, "spinifex-workers"},
|
||||
natsSub{"elbv2.RegisterTargets", d.handleELBv2RegisterTargets, "spinifex-workers"},
|
||||
natsSub{"elbv2.DeregisterTargets", d.handleELBv2DeregisterTargets, "spinifex-workers"},
|
||||
natsSub{"elbv2.DescribeTargetHealth", d.handleELBv2DescribeTargetHealth, "spinifex-workers"},
|
||||
natsSub{"elbv2.CreateListener", d.handleELBv2CreateListener, "spinifex-workers"},
|
||||
natsSub{"elbv2.DeleteListener", d.handleELBv2DeleteListener, "spinifex-workers"},
|
||||
natsSub{"elbv2.ModifyListener", d.handleELBv2ModifyListener, "spinifex-workers"},
|
||||
natsSub{"elbv2.DescribeListeners", d.handleELBv2DescribeListeners, "spinifex-workers"},
|
||||
natsSub{"elbv2.CreateRule", d.handleELBv2CreateRule, "spinifex-workers"},
|
||||
natsSub{"elbv2.ModifyRule", d.handleELBv2ModifyRule, "spinifex-workers"},
|
||||
natsSub{"elbv2.DeleteRule", d.handleELBv2DeleteRule, "spinifex-workers"},
|
||||
natsSub{"elbv2.DescribeRules", d.handleELBv2DescribeRules, "spinifex-workers"},
|
||||
natsSub{"elbv2.SetRulePriorities", d.handleELBv2SetRulePriorities, "spinifex-workers"},
|
||||
natsSub{"elbv2.DescribeTags", d.handleELBv2DescribeTags, "spinifex-workers"},
|
||||
natsSub{"elbv2.AddTags", d.handleELBv2AddTags, "spinifex-workers"},
|
||||
natsSub{"elbv2.RemoveTags", d.handleELBv2RemoveTags, "spinifex-workers"},
|
||||
natsSub{"elbv2.LBAgentHeartbeat", d.handleELBv2LBAgentHeartbeat, "spinifex-workers"},
|
||||
natsSub{"elbv2.GetLBConfig", d.handleELBv2GetLBConfig, "spinifex-workers"},
|
||||
natsSub{"elbv2.ModifyTargetGroupAttributes", d.handleELBv2ModifyTargetGroupAttributes, "spinifex-workers"},
|
||||
natsSub{"elbv2.DescribeTargetGroupAttributes", d.handleELBv2DescribeTargetGroupAttributes, "spinifex-workers"},
|
||||
natsSub{"elbv2.ModifyLoadBalancerAttributes", d.handleELBv2ModifyLoadBalancerAttributes, "spinifex-workers"},
|
||||
natsSub{"elbv2.DescribeLoadBalancerAttributes", d.handleELBv2DescribeLoadBalancerAttributes, "spinifex-workers"},
|
||||
natsSub{"elbv2.SetSecurityGroups", d.handleELBv2SetSecurityGroups, "spinifex-workers"},
|
||||
natsSub{"elbv2.SetIpAddressType", d.handleELBv2SetIpAddressType, "spinifex-workers"},
|
||||
natsSub{"elbv2.SetSubnets", d.handleELBv2SetSubnets, "spinifex-workers"},
|
||||
natsSub{"elbv2.AddListenerCertificates", d.handleELBv2AddListenerCertificates, "spinifex-workers"},
|
||||
natsSub{"elbv2.RemoveListenerCertificates", d.handleELBv2RemoveListenerCertificates, "spinifex-workers"},
|
||||
natsSub{"elbv2.DescribeListenerCertificates", d.handleELBv2DescribeListenerCertificates, "spinifex-workers"},
|
||||
natsSub{"elbv2.DescribeSSLPolicies", d.handleELBv2DescribeSSLPolicies, "spinifex-workers"},
|
||||
natsSub{"elbv2.CreateLoadBalancer", handleNATSRequest(d.elbv2Service.CreateLoadBalancer), "spinifex-workers"},
|
||||
natsSub{"elbv2.DeleteLoadBalancer", handleNATSRequest(d.elbv2Service.DeleteLoadBalancer), "spinifex-workers"},
|
||||
natsSub{"elbv2.DescribeLoadBalancers", handleNATSRequest(d.elbv2Service.DescribeLoadBalancers), "spinifex-workers"},
|
||||
natsSub{"elbv2.CreateTargetGroup", handleNATSRequest(d.elbv2Service.CreateTargetGroup), "spinifex-workers"},
|
||||
natsSub{"elbv2.ModifyTargetGroup", handleNATSRequest(d.elbv2Service.ModifyTargetGroup), "spinifex-workers"},
|
||||
natsSub{"elbv2.DeleteTargetGroup", handleNATSRequest(d.elbv2Service.DeleteTargetGroup), "spinifex-workers"},
|
||||
natsSub{"elbv2.DescribeTargetGroups", handleNATSRequest(d.elbv2Service.DescribeTargetGroups), "spinifex-workers"},
|
||||
natsSub{"elbv2.RegisterTargets", handleNATSRequest(d.elbv2Service.RegisterTargets), "spinifex-workers"},
|
||||
natsSub{"elbv2.DeregisterTargets", handleNATSRequest(d.elbv2Service.DeregisterTargets), "spinifex-workers"},
|
||||
natsSub{"elbv2.DescribeTargetHealth", handleNATSRequest(d.elbv2Service.DescribeTargetHealth), "spinifex-workers"},
|
||||
natsSub{"elbv2.CreateListener", handleNATSRequest(d.elbv2Service.CreateListener), "spinifex-workers"},
|
||||
natsSub{"elbv2.DeleteListener", handleNATSRequest(d.elbv2Service.DeleteListener), "spinifex-workers"},
|
||||
natsSub{"elbv2.ModifyListener", handleNATSRequest(d.elbv2Service.ModifyListener), "spinifex-workers"},
|
||||
natsSub{"elbv2.DescribeListeners", handleNATSRequest(d.elbv2Service.DescribeListeners), "spinifex-workers"},
|
||||
natsSub{"elbv2.CreateRule", handleNATSRequest(d.elbv2Service.CreateRule), "spinifex-workers"},
|
||||
natsSub{"elbv2.ModifyRule", handleNATSRequest(d.elbv2Service.ModifyRule), "spinifex-workers"},
|
||||
natsSub{"elbv2.DeleteRule", handleNATSRequest(d.elbv2Service.DeleteRule), "spinifex-workers"},
|
||||
natsSub{"elbv2.DescribeRules", handleNATSRequest(d.elbv2Service.DescribeRules), "spinifex-workers"},
|
||||
natsSub{"elbv2.SetRulePriorities", handleNATSRequest(d.elbv2Service.SetRulePriorities), "spinifex-workers"},
|
||||
natsSub{"elbv2.DescribeTags", handleNATSRequest(d.elbv2Service.DescribeTags), "spinifex-workers"},
|
||||
natsSub{"elbv2.AddTags", handleNATSRequest(d.elbv2Service.AddTags), "spinifex-workers"},
|
||||
natsSub{"elbv2.RemoveTags", handleNATSRequest(d.elbv2Service.RemoveTags), "spinifex-workers"},
|
||||
natsSub{"elbv2.LBAgentHeartbeat", handleNATSRequest(d.elbv2Service.LBAgentHeartbeat), "spinifex-workers"},
|
||||
natsSub{"elbv2.GetLBConfig", handleNATSRequest(d.elbv2Service.GetLBConfig), "spinifex-workers"},
|
||||
natsSub{"elbv2.ModifyTargetGroupAttributes", handleNATSRequest(d.elbv2Service.ModifyTargetGroupAttributes), "spinifex-workers"},
|
||||
natsSub{"elbv2.DescribeTargetGroupAttributes", handleNATSRequest(d.elbv2Service.DescribeTargetGroupAttributes), "spinifex-workers"},
|
||||
natsSub{"elbv2.ModifyLoadBalancerAttributes", handleNATSRequest(d.elbv2Service.ModifyLoadBalancerAttributes), "spinifex-workers"},
|
||||
natsSub{"elbv2.DescribeLoadBalancerAttributes", handleNATSRequest(d.elbv2Service.DescribeLoadBalancerAttributes), "spinifex-workers"},
|
||||
natsSub{"elbv2.SetSecurityGroups", handleNATSRequest(d.elbv2Service.SetSecurityGroups), "spinifex-workers"},
|
||||
natsSub{"elbv2.SetIpAddressType", handleNATSRequest(d.elbv2Service.SetIpAddressType), "spinifex-workers"},
|
||||
natsSub{"elbv2.SetSubnets", handleNATSRequest(d.elbv2Service.SetSubnets), "spinifex-workers"},
|
||||
natsSub{"elbv2.AddListenerCertificates", handleNATSRequest(d.elbv2Service.AddListenerCertificates), "spinifex-workers"},
|
||||
natsSub{"elbv2.RemoveListenerCertificates", handleNATSRequest(d.elbv2Service.RemoveListenerCertificates), "spinifex-workers"},
|
||||
natsSub{"elbv2.DescribeListenerCertificates", handleNATSRequest(d.elbv2Service.DescribeListenerCertificates), "spinifex-workers"},
|
||||
natsSub{"elbv2.DescribeSSLPolicies", handleNATSRequest(d.elbv2Service.DescribeSSLPolicies), "spinifex-workers"},
|
||||
)
|
||||
}
|
||||
|
||||
@@ -950,97 +952,97 @@ func (d *Daemon) subscribeAll() error {
|
||||
// stable while real bodies land.
|
||||
if d.eksService != nil {
|
||||
subs = append(subs,
|
||||
natsSub{"eks.CreateCluster", d.handleEKSCreateCluster, "spinifex-workers"},
|
||||
natsSub{"eks.DescribeCluster", d.handleEKSDescribeCluster, "spinifex-workers"},
|
||||
natsSub{"eks.ListClusters", d.handleEKSListClusters, "spinifex-workers"},
|
||||
natsSub{"eks.UpdateClusterConfig", d.handleEKSUpdateClusterConfig, "spinifex-workers"},
|
||||
natsSub{"eks.UpdateClusterVersion", d.handleEKSUpdateClusterVersion, "spinifex-workers"},
|
||||
natsSub{"eks.DeleteCluster", d.handleEKSDeleteCluster, "spinifex-workers"},
|
||||
natsSub{"eks.CreateNodegroup", d.handleEKSCreateNodegroup, "spinifex-workers"},
|
||||
natsSub{"eks.DescribeNodegroup", d.handleEKSDescribeNodegroup, "spinifex-workers"},
|
||||
natsSub{"eks.ListNodegroups", d.handleEKSListNodegroups, "spinifex-workers"},
|
||||
natsSub{"eks.UpdateNodegroupConfig", d.handleEKSUpdateNodegroupConfig, "spinifex-workers"},
|
||||
natsSub{"eks.UpdateNodegroupVersion", d.handleEKSUpdateNodegroupVersion, "spinifex-workers"},
|
||||
natsSub{"eks.DeleteNodegroup", d.handleEKSDeleteNodegroup, "spinifex-workers"},
|
||||
natsSub{"eks.CreateAccessEntry", d.handleEKSCreateAccessEntry, "spinifex-workers"},
|
||||
natsSub{"eks.DescribeAccessEntry", d.handleEKSDescribeAccessEntry, "spinifex-workers"},
|
||||
natsSub{"eks.ListAccessEntries", d.handleEKSListAccessEntries, "spinifex-workers"},
|
||||
natsSub{"eks.UpdateAccessEntry", d.handleEKSUpdateAccessEntry, "spinifex-workers"},
|
||||
natsSub{"eks.DeleteAccessEntry", d.handleEKSDeleteAccessEntry, "spinifex-workers"},
|
||||
natsSub{"eks.AssociateAccessPolicy", d.handleEKSAssociateAccessPolicy, "spinifex-workers"},
|
||||
natsSub{"eks.DisassociateAccessPolicy", d.handleEKSDisassociateAccessPolicy, "spinifex-workers"},
|
||||
natsSub{"eks.ListAssociatedAccessPolicies", d.handleEKSListAssociatedAccessPolicies, "spinifex-workers"},
|
||||
natsSub{"eks.ListAccessPolicies", d.handleEKSListAccessPolicies, "spinifex-workers"},
|
||||
natsSub{"eks.ListAddons", d.handleEKSListAddons, "spinifex-workers"},
|
||||
natsSub{"eks.DescribeAddonVersions", d.handleEKSDescribeAddonVersions, "spinifex-workers"},
|
||||
natsSub{"eks.CreateAddon", d.handleEKSCreateAddon, "spinifex-workers"},
|
||||
natsSub{"eks.DeleteAddon", d.handleEKSDeleteAddon, "spinifex-workers"},
|
||||
natsSub{"eks.DescribeAddon", d.handleEKSDescribeAddon, "spinifex-workers"},
|
||||
natsSub{"eks.UpdateAddon", d.handleEKSUpdateAddon, "spinifex-workers"},
|
||||
natsSub{"eks.ListStagedAddonManifests", d.handleEKSListStagedAddonManifests, "spinifex-workers"},
|
||||
natsSub{"eks.GetRecoveryDirective", d.handleEKSGetRecoveryDirective, "spinifex-workers"},
|
||||
natsSub{"eks.SetRecoveryDirective", d.handleEKSSetRecoveryDirective, "spinifex-workers"},
|
||||
natsSub{"eks.RestoreSnapshot", d.handleEKSRestoreSnapshot, "spinifex-workers"},
|
||||
natsSub{"eks.AssociateIdentityProviderConfig", d.handleEKSAssociateIdentityProviderConfig, "spinifex-workers"},
|
||||
natsSub{"eks.DescribeIdentityProviderConfig", d.handleEKSDescribeIdentityProviderConfig, "spinifex-workers"},
|
||||
natsSub{"eks.ListIdentityProviderConfigs", d.handleEKSListIdentityProviderConfigs, "spinifex-workers"},
|
||||
natsSub{"eks.DisassociateIdentityProviderConfig", d.handleEKSDisassociateIdentityProviderConfig, "spinifex-workers"},
|
||||
natsSub{"eks.TagResource", d.handleEKSTagResource, "spinifex-workers"},
|
||||
natsSub{"eks.UntagResource", d.handleEKSUntagResource, "spinifex-workers"},
|
||||
natsSub{"eks.ListTagsForResource", d.handleEKSListTagsForResource, "spinifex-workers"},
|
||||
natsSub{"eks.CreateCluster", handleNATSRequestWithPrincipal(d.eksService.CreateCluster), "spinifex-workers"},
|
||||
natsSub{"eks.DescribeCluster", handleNATSRequest(d.eksService.DescribeCluster), "spinifex-workers"},
|
||||
natsSub{"eks.ListClusters", handleNATSRequest(d.eksService.ListClusters), "spinifex-workers"},
|
||||
natsSub{"eks.UpdateClusterConfig", handleNATSRequest(d.eksService.UpdateClusterConfig), "spinifex-workers"},
|
||||
natsSub{"eks.UpdateClusterVersion", handleNATSRequest(d.eksService.UpdateClusterVersion), "spinifex-workers"},
|
||||
natsSub{"eks.DeleteCluster", handleNATSRequest(d.eksService.DeleteCluster), "spinifex-workers"},
|
||||
natsSub{"eks.CreateNodegroup", handleNATSRequest(d.eksService.CreateNodegroup), "spinifex-workers"},
|
||||
natsSub{"eks.DescribeNodegroup", handleNATSRequest(d.eksService.DescribeNodegroup), "spinifex-workers"},
|
||||
natsSub{"eks.ListNodegroups", handleNATSRequest(d.eksService.ListNodegroups), "spinifex-workers"},
|
||||
natsSub{"eks.UpdateNodegroupConfig", handleNATSRequest(d.eksService.UpdateNodegroupConfig), "spinifex-workers"},
|
||||
natsSub{"eks.UpdateNodegroupVersion", handleNATSRequest(d.eksService.UpdateNodegroupVersion), "spinifex-workers"},
|
||||
natsSub{"eks.DeleteNodegroup", handleNATSRequest(d.eksService.DeleteNodegroup), "spinifex-workers"},
|
||||
natsSub{"eks.CreateAccessEntry", handleNATSRequest(d.eksService.CreateAccessEntry), "spinifex-workers"},
|
||||
natsSub{"eks.DescribeAccessEntry", handleNATSRequest(d.eksService.DescribeAccessEntry), "spinifex-workers"},
|
||||
natsSub{"eks.ListAccessEntries", handleNATSRequest(d.eksService.ListAccessEntries), "spinifex-workers"},
|
||||
natsSub{"eks.UpdateAccessEntry", handleNATSRequest(d.eksService.UpdateAccessEntry), "spinifex-workers"},
|
||||
natsSub{"eks.DeleteAccessEntry", handleNATSRequest(d.eksService.DeleteAccessEntry), "spinifex-workers"},
|
||||
natsSub{"eks.AssociateAccessPolicy", handleNATSRequest(d.eksService.AssociateAccessPolicy), "spinifex-workers"},
|
||||
natsSub{"eks.DisassociateAccessPolicy", handleNATSRequest(d.eksService.DisassociateAccessPolicy), "spinifex-workers"},
|
||||
natsSub{"eks.ListAssociatedAccessPolicies", handleNATSRequest(d.eksService.ListAssociatedAccessPolicies), "spinifex-workers"},
|
||||
natsSub{"eks.ListAccessPolicies", handleNATSRequest(d.eksService.ListAccessPolicies), "spinifex-workers"},
|
||||
natsSub{"eks.ListAddons", handleNATSRequest(d.eksService.ListAddons), "spinifex-workers"},
|
||||
natsSub{"eks.DescribeAddonVersions", handleNATSRequest(d.eksService.DescribeAddonVersions), "spinifex-workers"},
|
||||
natsSub{"eks.CreateAddon", handleNATSRequest(d.eksService.CreateAddon), "spinifex-workers"},
|
||||
natsSub{"eks.DeleteAddon", handleNATSRequest(d.eksService.DeleteAddon), "spinifex-workers"},
|
||||
natsSub{"eks.DescribeAddon", handleNATSRequest(d.eksService.DescribeAddon), "spinifex-workers"},
|
||||
natsSub{"eks.UpdateAddon", handleNATSRequest(d.eksService.UpdateAddon), "spinifex-workers"},
|
||||
natsSub{"eks.ListStagedAddonManifests", handleNATSRequest(d.eksService.ListStagedAddonManifests), "spinifex-workers"},
|
||||
natsSub{"eks.GetRecoveryDirective", handleNATSRequest(d.eksService.GetRecoveryDirective), "spinifex-workers"},
|
||||
natsSub{"eks.SetRecoveryDirective", handleNATSRequest(d.eksService.SetRecoveryDirective), "spinifex-workers"},
|
||||
natsSub{"eks.RestoreSnapshot", handleNATSRequest(d.eksService.RestoreSnapshot), "spinifex-workers"},
|
||||
natsSub{"eks.AssociateIdentityProviderConfig", handleNATSRequest(d.eksService.AssociateIdentityProviderConfig), "spinifex-workers"},
|
||||
natsSub{"eks.DescribeIdentityProviderConfig", handleNATSRequest(d.eksService.DescribeIdentityProviderConfig), "spinifex-workers"},
|
||||
natsSub{"eks.ListIdentityProviderConfigs", handleNATSRequest(d.eksService.ListIdentityProviderConfigs), "spinifex-workers"},
|
||||
natsSub{"eks.DisassociateIdentityProviderConfig", handleNATSRequest(d.eksService.DisassociateIdentityProviderConfig), "spinifex-workers"},
|
||||
natsSub{"eks.TagResource", handleNATSRequest(d.eksService.TagResource), "spinifex-workers"},
|
||||
natsSub{"eks.UntagResource", handleNATSRequest(d.eksService.UntagResource), "spinifex-workers"},
|
||||
natsSub{"eks.ListTagsForResource", handleNATSRequest(d.eksService.ListTagsForResource), "spinifex-workers"},
|
||||
)
|
||||
}
|
||||
|
||||
// ECS gateway → daemon subscriptions (control plane; per-account KV).
|
||||
if d.ecsService != nil {
|
||||
subs = append(subs,
|
||||
natsSub{"ecs.CreateCluster", d.handleECSCreateCluster, "spinifex-workers"},
|
||||
natsSub{"ecs.DeleteCluster", d.handleECSDeleteCluster, "spinifex-workers"},
|
||||
natsSub{"ecs.DescribeClusters", d.handleECSDescribeClusters, "spinifex-workers"},
|
||||
natsSub{"ecs.ListClusters", d.handleECSListClusters, "spinifex-workers"},
|
||||
natsSub{"ecs.RegisterTaskDefinition", d.handleECSRegisterTaskDefinition, "spinifex-workers"},
|
||||
natsSub{"ecs.DeregisterTaskDefinition", d.handleECSDeregisterTaskDefinition, "spinifex-workers"},
|
||||
natsSub{"ecs.DescribeTaskDefinition", d.handleECSDescribeTaskDefinition, "spinifex-workers"},
|
||||
natsSub{"ecs.ListTaskDefinitions", d.handleECSListTaskDefinitions, "spinifex-workers"},
|
||||
natsSub{"ecs.RegisterContainerInstance", d.handleECSRegisterContainerInstance, "spinifex-workers"},
|
||||
natsSub{"ecs.DeregisterContainerInstance", d.handleECSDeregisterContainerInstance, "spinifex-workers"},
|
||||
natsSub{"ecs.UpdateContainerInstancesState", d.handleECSUpdateContainerInstancesState, "spinifex-workers"},
|
||||
natsSub{"ecs.DescribeContainerInstances", d.handleECSDescribeContainerInstances, "spinifex-workers"},
|
||||
natsSub{"ecs.ListContainerInstances", d.handleECSListContainerInstances, "spinifex-workers"},
|
||||
natsSub{"ecs.RunTask", d.handleECSRunTask, "spinifex-workers"},
|
||||
natsSub{"ecs.StartTask", d.handleECSStartTask, "spinifex-workers"},
|
||||
natsSub{"ecs.StopTask", d.handleECSStopTask, "spinifex-workers"},
|
||||
natsSub{"ecs.DescribeTasks", d.handleECSDescribeTasks, "spinifex-workers"},
|
||||
natsSub{"ecs.ListTasks", d.handleECSListTasks, "spinifex-workers"},
|
||||
natsSub{"ecs.CreateService", d.handleECSCreateService, "spinifex-workers"},
|
||||
natsSub{"ecs.UpdateService", d.handleECSUpdateService, "spinifex-workers"},
|
||||
natsSub{"ecs.DeleteService", d.handleECSDeleteService, "spinifex-workers"},
|
||||
natsSub{"ecs.DescribeServices", d.handleECSDescribeServices, "spinifex-workers"},
|
||||
natsSub{"ecs.ListServices", d.handleECSListServices, "spinifex-workers"},
|
||||
natsSub{"ecs.SubmitTaskStateChange", d.handleECSSubmitTaskStateChange, "spinifex-workers"},
|
||||
natsSub{"ecs.PollAssignments", d.handleECSPollAssignments, "spinifex-workers"},
|
||||
natsSub{"ecs.ReportTaskGPU", d.handleECSReportTaskGPU, "spinifex-workers"},
|
||||
natsSub{"ecs.ProvisionCapacity", d.handleECSProvisionCapacity, "spinifex-workers"},
|
||||
natsSub{"ecs.TagResource", d.handleECSTagResource, "spinifex-workers"},
|
||||
natsSub{"ecs.UntagResource", d.handleECSUntagResource, "spinifex-workers"},
|
||||
natsSub{"ecs.ListTagsForResource", d.handleECSListTagsForResource, "spinifex-workers"},
|
||||
natsSub{"ecs.PutClusterCapacityProviders", d.handleECSPutClusterCapacityProviders, "spinifex-workers"},
|
||||
natsSub{"ecs.CreateCapacityProvider", d.handleECSCreateCapacityProvider, "spinifex-workers"},
|
||||
natsSub{"ecs.DescribeCapacityProviders", d.handleECSDescribeCapacityProviders, "spinifex-workers"},
|
||||
natsSub{"ecs.DeleteCapacityProvider", d.handleECSDeleteCapacityProvider, "spinifex-workers"},
|
||||
natsSub{"ecs.CreateCluster", handleNATSRequest(d.ecsService.CreateCluster), "spinifex-workers"},
|
||||
natsSub{"ecs.DeleteCluster", handleNATSRequest(d.ecsService.DeleteCluster), "spinifex-workers"},
|
||||
natsSub{"ecs.DescribeClusters", handleNATSRequest(d.ecsService.DescribeClusters), "spinifex-workers"},
|
||||
natsSub{"ecs.ListClusters", handleNATSRequest(d.ecsService.ListClusters), "spinifex-workers"},
|
||||
natsSub{"ecs.RegisterTaskDefinition", handleNATSRequest(d.ecsService.RegisterTaskDefinition), "spinifex-workers"},
|
||||
natsSub{"ecs.DeregisterTaskDefinition", handleNATSRequest(d.ecsService.DeregisterTaskDefinition), "spinifex-workers"},
|
||||
natsSub{"ecs.DescribeTaskDefinition", handleNATSRequest(d.ecsService.DescribeTaskDefinition), "spinifex-workers"},
|
||||
natsSub{"ecs.ListTaskDefinitions", handleNATSRequest(d.ecsService.ListTaskDefinitions), "spinifex-workers"},
|
||||
natsSub{"ecs.RegisterContainerInstance", handleNATSRequest(d.ecsService.RegisterContainerInstance), "spinifex-workers"},
|
||||
natsSub{"ecs.DeregisterContainerInstance", handleNATSRequest(d.ecsService.DeregisterContainerInstance), "spinifex-workers"},
|
||||
natsSub{"ecs.UpdateContainerInstancesState", handleNATSRequest(d.ecsService.UpdateContainerInstancesState), "spinifex-workers"},
|
||||
natsSub{"ecs.DescribeContainerInstances", handleNATSRequest(d.ecsService.DescribeContainerInstances), "spinifex-workers"},
|
||||
natsSub{"ecs.ListContainerInstances", handleNATSRequest(d.ecsService.ListContainerInstances), "spinifex-workers"},
|
||||
natsSub{"ecs.RunTask", handleNATSRequest(d.ecsService.RunTask), "spinifex-workers"},
|
||||
natsSub{"ecs.StartTask", handleNATSRequest(d.ecsService.StartTask), "spinifex-workers"},
|
||||
natsSub{"ecs.StopTask", handleNATSRequest(d.ecsService.StopTask), "spinifex-workers"},
|
||||
natsSub{"ecs.DescribeTasks", handleNATSRequest(d.ecsService.DescribeTasks), "spinifex-workers"},
|
||||
natsSub{"ecs.ListTasks", handleNATSRequest(d.ecsService.ListTasks), "spinifex-workers"},
|
||||
natsSub{"ecs.CreateService", handleNATSRequest(d.ecsService.CreateService), "spinifex-workers"},
|
||||
natsSub{"ecs.UpdateService", handleNATSRequest(d.ecsService.UpdateService), "spinifex-workers"},
|
||||
natsSub{"ecs.DeleteService", handleNATSRequest(d.ecsService.DeleteService), "spinifex-workers"},
|
||||
natsSub{"ecs.DescribeServices", handleNATSRequest(d.ecsService.DescribeServices), "spinifex-workers"},
|
||||
natsSub{"ecs.ListServices", handleNATSRequest(d.ecsService.ListServices), "spinifex-workers"},
|
||||
natsSub{"ecs.SubmitTaskStateChange", handleNATSRequest(d.ecsService.SubmitTaskStateChange), "spinifex-workers"},
|
||||
natsSub{"ecs.PollAssignments", handleNATSRequest(d.ecsService.PollAssignments), "spinifex-workers"},
|
||||
natsSub{"ecs.ReportTaskGPU", handleNATSRequest(d.ecsService.ReportTaskGPU), "spinifex-workers"},
|
||||
natsSub{"ecs.ProvisionCapacity", handleNATSRequest(d.ecsService.ProvisionCapacity), "spinifex-workers"},
|
||||
natsSub{"ecs.TagResource", handleNATSRequest(d.ecsService.TagResource), "spinifex-workers"},
|
||||
natsSub{"ecs.UntagResource", handleNATSRequest(d.ecsService.UntagResource), "spinifex-workers"},
|
||||
natsSub{"ecs.ListTagsForResource", handleNATSRequest(d.ecsService.ListTagsForResource), "spinifex-workers"},
|
||||
natsSub{"ecs.PutClusterCapacityProviders", handleNATSRequest(d.ecsService.PutClusterCapacityProviders), "spinifex-workers"},
|
||||
natsSub{"ecs.CreateCapacityProvider", handleNATSRequest(d.ecsService.CreateCapacityProvider), "spinifex-workers"},
|
||||
natsSub{"ecs.DescribeCapacityProviders", handleNATSRequest(d.ecsService.DescribeCapacityProviders), "spinifex-workers"},
|
||||
natsSub{"ecs.DeleteCapacityProvider", handleNATSRequest(d.ecsService.DeleteCapacityProvider), "spinifex-workers"},
|
||||
)
|
||||
}
|
||||
|
||||
// ACM gateway → daemon subscriptions (minimal certificate store).
|
||||
if d.acmService != nil {
|
||||
subs = append(subs,
|
||||
natsSub{"acm.ImportCertificate", d.handleACMImportCertificate, "spinifex-workers"},
|
||||
natsSub{"acm.DescribeCertificate", d.handleACMDescribeCertificate, "spinifex-workers"},
|
||||
natsSub{"acm.ListCertificates", d.handleACMListCertificates, "spinifex-workers"},
|
||||
natsSub{"acm.DeleteCertificate", d.handleACMDeleteCertificate, "spinifex-workers"},
|
||||
natsSub{"acm.ListTagsForCertificate", d.handleACMListTagsForCertificate, "spinifex-workers"},
|
||||
natsSub{"acm.AddTagsToCertificate", d.handleACMAddTagsToCertificate, "spinifex-workers"},
|
||||
natsSub{"acm.RemoveTagsFromCertificate", d.handleACMRemoveTagsFromCertificate, "spinifex-workers"},
|
||||
natsSub{"acm.ImportCertificate", handleNATSRequest(d.acmService.ImportCertificate), "spinifex-workers"},
|
||||
natsSub{"acm.DescribeCertificate", handleNATSRequest(d.acmService.DescribeCertificate), "spinifex-workers"},
|
||||
natsSub{"acm.ListCertificates", handleNATSRequest(d.acmService.ListCertificates), "spinifex-workers"},
|
||||
natsSub{"acm.DeleteCertificate", handleNATSRequest(d.acmService.DeleteCertificate), "spinifex-workers"},
|
||||
natsSub{"acm.ListTagsForCertificate", handleNATSRequest(d.acmService.ListTagsForCertificate), "spinifex-workers"},
|
||||
natsSub{"acm.AddTagsToCertificate", handleNATSRequest(d.acmService.AddTagsToCertificate), "spinifex-workers"},
|
||||
natsSub{"acm.RemoveTagsFromCertificate", handleNATSRequest(d.acmService.RemoveTagsFromCertificate), "spinifex-workers"},
|
||||
)
|
||||
}
|
||||
|
||||
@@ -1048,28 +1050,28 @@ func (d *Daemon) subscribeAll() error {
|
||||
// JetStream KV metadata; blob/manifest bytes never traverse these subjects.
|
||||
if d.ecrMetaService != nil {
|
||||
subs = append(subs,
|
||||
natsSub{handlers_ecr.SubjectRepoCreate, d.handleECRRepoCreate, "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectRepoDescribe, d.handleECRRepoDescribe, "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectRepoList, d.handleECRRepoList, "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectRepoDelete, d.handleECRRepoDelete, "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectPolicyPut, d.handleECRPolicyPut, "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectPolicyGet, d.handleECRPolicyGet, "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectPolicyDelete, d.handleECRPolicyDelete, "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectLifecyclePut, d.handleECRLifecyclePut, "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectLifecycleGet, d.handleECRLifecycleGet, "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectLifecycleDelete, d.handleECRLifecycleDelete, "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectTagPut, d.handleECRTagPut, "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectTagGet, d.handleECRTagGet, "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectTagList, d.handleECRTagList, "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectTagDelete, d.handleECRTagDelete, "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectManifestPut, d.handleECRManifestPut, "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectManifestDescribe, d.handleECRManifestDescribe, "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectManifestList, d.handleECRManifestList, "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectManifestDelete, d.handleECRManifestDelete, "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectUploadCreate, d.handleECRUploadCreate, "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectUploadGet, d.handleECRUploadGet, "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectUploadUpdate, d.handleECRUploadUpdate, "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectUploadDelete, d.handleECRUploadDelete, "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectRepoCreate, handleNATSRequest(d.ecrMetaService.RepoCreate), "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectRepoDescribe, handleNATSRequest(d.ecrMetaService.RepoDescribe), "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectRepoList, handleNATSRequest(d.ecrMetaService.RepoList), "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectRepoDelete, handleNATSRequest(d.ecrMetaService.RepoDelete), "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectPolicyPut, handleNATSRequest(d.ecrMetaService.PolicyPut), "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectPolicyGet, handleNATSRequest(d.ecrMetaService.PolicyGet), "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectPolicyDelete, handleNATSRequest(d.ecrMetaService.PolicyDelete), "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectLifecyclePut, handleNATSRequest(d.ecrMetaService.LifecyclePut), "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectLifecycleGet, handleNATSRequest(d.ecrMetaService.LifecycleGet), "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectLifecycleDelete, handleNATSRequest(d.ecrMetaService.LifecycleDelete), "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectTagPut, handleNATSRequest(d.ecrMetaService.TagPut), "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectTagGet, handleNATSRequest(d.ecrMetaService.TagGet), "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectTagList, handleNATSRequest(d.ecrMetaService.TagList), "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectTagDelete, handleNATSRequest(d.ecrMetaService.TagDelete), "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectManifestPut, handleNATSRequest(d.ecrMetaService.ManifestPut), "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectManifestDescribe, handleNATSRequest(d.ecrMetaService.ManifestDescribe), "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectManifestList, handleNATSRequest(d.ecrMetaService.ManifestList), "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectManifestDelete, handleNATSRequest(d.ecrMetaService.ManifestDelete), "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectUploadCreate, handleNATSRequest(d.ecrMetaService.UploadCreate), "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectUploadGet, handleNATSRequest(d.ecrMetaService.UploadGet), "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectUploadUpdate, handleNATSRequest(d.ecrMetaService.UploadUpdate), "spinifex-workers"},
|
||||
natsSub{handlers_ecr.SubjectUploadDelete, handleNATSRequest(d.ecrMetaService.UploadDelete), "spinifex-workers"},
|
||||
)
|
||||
}
|
||||
|
||||
@@ -1077,12 +1079,12 @@ func (d *Daemon) subscribeAll() error {
|
||||
// the disabled stub, so reads return empty lists and mutations a clean
|
||||
// UnsupportedOperation instead of a NATS timeout.
|
||||
subs = append(subs,
|
||||
natsSub{"ec2.AllocateAddress", d.handleEC2AllocateAddress, "spinifex-workers"},
|
||||
natsSub{"ec2.ReleaseAddress", d.handleEC2ReleaseAddress, "spinifex-workers"},
|
||||
natsSub{"ec2.AssociateAddress", d.handleEC2AssociateAddress, "spinifex-workers"},
|
||||
natsSub{"ec2.DisassociateAddress", d.handleEC2DisassociateAddress, "spinifex-workers"},
|
||||
natsSub{"ec2.DescribeAddresses", d.handleEC2DescribeAddresses, "spinifex-workers"},
|
||||
natsSub{"ec2.DescribeAddressesAttribute", d.handleEC2DescribeAddressesAttribute, "spinifex-workers"},
|
||||
natsSub{"ec2.AllocateAddress", handleNATSRequest(d.eipService.AllocateAddress), "spinifex-workers"},
|
||||
natsSub{"ec2.ReleaseAddress", handleNATSRequest(d.eipService.ReleaseAddress), "spinifex-workers"},
|
||||
natsSub{"ec2.AssociateAddress", handleNATSRequest(d.eipService.AssociateAddress), "spinifex-workers"},
|
||||
natsSub{"ec2.DisassociateAddress", handleNATSRequest(d.eipService.DisassociateAddress), "spinifex-workers"},
|
||||
natsSub{"ec2.DescribeAddresses", handleNATSRequest(d.eipService.DescribeAddresses), "spinifex-workers"},
|
||||
natsSub{"ec2.DescribeAddressesAttribute", handleNATSRequest(d.eipService.DescribeAddressesAttribute), "spinifex-workers"},
|
||||
)
|
||||
|
||||
for _, s := range subs {
|
||||
|
||||
@@ -66,60 +66,65 @@ func respondWithJSON(msg *nats.Msg, data any) {
|
||||
}
|
||||
}
|
||||
|
||||
// handleNATSRequest is a generic helper for the common unmarshal → service → marshal → respond pattern.
|
||||
// It opens a consumer span joining the producer's trace, extracts the account ID
|
||||
// from the NATS message header, and passes both to the service function.
|
||||
func handleNATSRequest[I any, O any](msg *nats.Msg, serviceFn func(context.Context, *I, string) (*O, error)) {
|
||||
ctx, span := utils.StartConsumerSpan(msg)
|
||||
defer span.End()
|
||||
// handleNATSRequest returns the nats.MsgHandler for the common unmarshal → service →
|
||||
// marshal → respond pattern. Per message the handler opens a consumer span joining the
|
||||
// producer's trace, extracts the account ID from the NATS message header, and passes
|
||||
// both to the service function.
|
||||
func handleNATSRequest[I any, O any](serviceFn func(context.Context, *I, string) (*O, error)) nats.MsgHandler {
|
||||
return func(msg *nats.Msg) {
|
||||
ctx, span := utils.StartConsumerSpan(msg)
|
||||
defer span.End()
|
||||
|
||||
accountID := utils.AccountIDFromMsg(msg)
|
||||
input := new(I)
|
||||
if errResp := utils.UnmarshalJsonPayload(input, msg.Data); errResp != nil {
|
||||
utils.MarkSpanError(span, errors.New(awserrors.ErrorInvalidParameterValue))
|
||||
if err := msg.Respond(errResp); err != nil {
|
||||
slog.ErrorContext(ctx, "Failed to respond to NATS request", "err", err)
|
||||
accountID := utils.AccountIDFromMsg(msg)
|
||||
input := new(I)
|
||||
if errResp := utils.UnmarshalJsonPayload(input, msg.Data); errResp != nil {
|
||||
utils.MarkSpanError(span, errors.New(awserrors.ErrorInvalidParameterValue))
|
||||
if err := msg.Respond(errResp); err != nil {
|
||||
slog.ErrorContext(ctx, "Failed to respond to NATS request", "err", err)
|
||||
}
|
||||
return
|
||||
}
|
||||
return
|
||||
output, err := serviceFn(ctx, input, accountID)
|
||||
if err != nil {
|
||||
// The error was otherwise only recorded on the OTel span, invisible
|
||||
// without a trace backend. Log at Error so handler failures show up
|
||||
// in the journal too.
|
||||
slog.ErrorContext(ctx, "handleNATSRequest: service call failed", "subject", msg.Subject, "err", err)
|
||||
utils.MarkSpanError(span, err)
|
||||
respondWithError(msg, awserrors.ValidErrorCode(err.Error()))
|
||||
return
|
||||
}
|
||||
respondWithJSON(msg, output)
|
||||
}
|
||||
output, err := serviceFn(ctx, input, accountID)
|
||||
if err != nil {
|
||||
// The error was otherwise only recorded on the OTel span, invisible
|
||||
// without a trace backend. Log at Error so handler failures show up
|
||||
// in the journal too.
|
||||
slog.ErrorContext(ctx, "handleNATSRequest: service call failed", "subject", msg.Subject, "err", err)
|
||||
utils.MarkSpanError(span, err)
|
||||
respondWithError(msg, awserrors.ValidErrorCode(err.Error()))
|
||||
return
|
||||
}
|
||||
respondWithJSON(msg, output)
|
||||
}
|
||||
|
||||
// handleNATSRequestWithPrincipal is handleNATSRequest for service methods that
|
||||
// also need the caller's IAM principal ARN (X-Principal-ARN header) — e.g. EKS
|
||||
// CreateCluster, which mints the bootstrap-creator-admin AccessEntry for the
|
||||
// caller.
|
||||
func handleNATSRequestWithPrincipal[I any, O any](msg *nats.Msg, serviceFn func(context.Context, *I, string, string) (*O, error)) {
|
||||
ctx, span := utils.StartConsumerSpan(msg)
|
||||
defer span.End()
|
||||
func handleNATSRequestWithPrincipal[I any, O any](serviceFn func(context.Context, *I, string, string) (*O, error)) nats.MsgHandler {
|
||||
return func(msg *nats.Msg) {
|
||||
ctx, span := utils.StartConsumerSpan(msg)
|
||||
defer span.End()
|
||||
|
||||
accountID := utils.AccountIDFromMsg(msg)
|
||||
principalARN := utils.PrincipalARNFromMsg(msg)
|
||||
input := new(I)
|
||||
if errResp := utils.UnmarshalJsonPayload(input, msg.Data); errResp != nil {
|
||||
utils.MarkSpanError(span, errors.New(awserrors.ErrorInvalidParameterValue))
|
||||
if err := msg.Respond(errResp); err != nil {
|
||||
slog.ErrorContext(ctx, "Failed to respond to NATS request", "err", err)
|
||||
accountID := utils.AccountIDFromMsg(msg)
|
||||
principalARN := utils.PrincipalARNFromMsg(msg)
|
||||
input := new(I)
|
||||
if errResp := utils.UnmarshalJsonPayload(input, msg.Data); errResp != nil {
|
||||
utils.MarkSpanError(span, errors.New(awserrors.ErrorInvalidParameterValue))
|
||||
if err := msg.Respond(errResp); err != nil {
|
||||
slog.ErrorContext(ctx, "Failed to respond to NATS request", "err", err)
|
||||
}
|
||||
return
|
||||
}
|
||||
return
|
||||
output, err := serviceFn(ctx, input, accountID, principalARN)
|
||||
if err != nil {
|
||||
utils.MarkSpanError(span, err)
|
||||
respondWithError(msg, awserrors.ValidErrorCode(err.Error()))
|
||||
return
|
||||
}
|
||||
respondWithJSON(msg, output)
|
||||
}
|
||||
output, err := serviceFn(ctx, input, accountID, principalARN)
|
||||
if err != nil {
|
||||
utils.MarkSpanError(span, err)
|
||||
respondWithError(msg, awserrors.ValidErrorCode(err.Error()))
|
||||
return
|
||||
}
|
||||
respondWithJSON(msg, output)
|
||||
}
|
||||
|
||||
// handleEC2Events processes incoming EC2 instance events (start, stop, terminate, attach-volume).
|
||||
|
||||
@@ -1,29 +0,0 @@
|
||||
package daemon
|
||||
|
||||
import (
|
||||
"github.com/nats-io/nats.go"
|
||||
)
|
||||
|
||||
func (d *Daemon) handleEC2EnableEbsEncryptionByDefault(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.accountService.EnableEbsEncryptionByDefault)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DisableEbsEncryptionByDefault(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.accountService.DisableEbsEncryptionByDefault)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2GetEbsEncryptionByDefault(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.accountService.GetEbsEncryptionByDefault)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2GetSerialConsoleAccessStatus(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.accountService.GetSerialConsoleAccessStatus)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2EnableSerialConsoleAccess(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.accountService.EnableSerialConsoleAccess)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DisableSerialConsoleAccess(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.accountService.DisableSerialConsoleAccess)
|
||||
}
|
||||
@@ -1,31 +0,0 @@
|
||||
package daemon
|
||||
|
||||
import "github.com/nats-io/nats.go"
|
||||
|
||||
func (d *Daemon) handleACMImportCertificate(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.acmService.ImportCertificate)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleACMDescribeCertificate(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.acmService.DescribeCertificate)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleACMListCertificates(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.acmService.ListCertificates)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleACMDeleteCertificate(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.acmService.DeleteCertificate)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleACMListTagsForCertificate(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.acmService.ListTagsForCertificate)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleACMAddTagsToCertificate(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.acmService.AddTagsToCertificate)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleACMRemoveTagsFromCertificate(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.acmService.RemoveTagsFromCertificate)
|
||||
}
|
||||
@@ -1,91 +0,0 @@
|
||||
package daemon
|
||||
|
||||
import "github.com/nats-io/nats.go"
|
||||
|
||||
func (d *Daemon) handleECRRepoCreate(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecrMetaService.RepoCreate)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECRRepoDescribe(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecrMetaService.RepoDescribe)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECRRepoList(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecrMetaService.RepoList)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECRRepoDelete(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecrMetaService.RepoDelete)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECRPolicyPut(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecrMetaService.PolicyPut)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECRPolicyGet(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecrMetaService.PolicyGet)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECRPolicyDelete(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecrMetaService.PolicyDelete)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECRLifecyclePut(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecrMetaService.LifecyclePut)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECRLifecycleGet(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecrMetaService.LifecycleGet)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECRLifecycleDelete(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecrMetaService.LifecycleDelete)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECRTagPut(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecrMetaService.TagPut)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECRTagGet(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecrMetaService.TagGet)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECRTagList(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecrMetaService.TagList)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECRTagDelete(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecrMetaService.TagDelete)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECRManifestPut(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecrMetaService.ManifestPut)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECRManifestDescribe(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecrMetaService.ManifestDescribe)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECRManifestList(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecrMetaService.ManifestList)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECRManifestDelete(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecrMetaService.ManifestDelete)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECRUploadCreate(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecrMetaService.UploadCreate)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECRUploadGet(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecrMetaService.UploadGet)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECRUploadUpdate(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecrMetaService.UploadUpdate)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECRUploadDelete(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecrMetaService.UploadDelete)
|
||||
}
|
||||
@@ -1,155 +0,0 @@
|
||||
package daemon
|
||||
|
||||
import "github.com/nats-io/nats.go"
|
||||
|
||||
// --- Cluster ---
|
||||
|
||||
func (d *Daemon) handleECSCreateCluster(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.CreateCluster)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECSDeleteCluster(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.DeleteCluster)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECSDescribeClusters(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.DescribeClusters)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECSListClusters(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.ListClusters)
|
||||
}
|
||||
|
||||
// --- Task definition ---
|
||||
|
||||
func (d *Daemon) handleECSRegisterTaskDefinition(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.RegisterTaskDefinition)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECSDeregisterTaskDefinition(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.DeregisterTaskDefinition)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECSDescribeTaskDefinition(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.DescribeTaskDefinition)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECSListTaskDefinitions(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.ListTaskDefinitions)
|
||||
}
|
||||
|
||||
// --- Container instance ---
|
||||
|
||||
func (d *Daemon) handleECSRegisterContainerInstance(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.RegisterContainerInstance)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECSDeregisterContainerInstance(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.DeregisterContainerInstance)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECSUpdateContainerInstancesState(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.UpdateContainerInstancesState)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECSDescribeContainerInstances(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.DescribeContainerInstances)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECSListContainerInstances(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.ListContainerInstances)
|
||||
}
|
||||
|
||||
// --- Task ---
|
||||
|
||||
func (d *Daemon) handleECSRunTask(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.RunTask)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECSStartTask(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.StartTask)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECSStopTask(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.StopTask)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECSDescribeTasks(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.DescribeTasks)
|
||||
}
|
||||
|
||||
// --- Service ---
|
||||
|
||||
func (d *Daemon) handleECSCreateService(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.CreateService)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECSUpdateService(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.UpdateService)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECSDeleteService(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.DeleteService)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECSDescribeServices(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.DescribeServices)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECSListServices(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.ListServices)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECSSubmitTaskStateChange(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.SubmitTaskStateChange)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECSListTasks(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.ListTasks)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECSPollAssignments(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.PollAssignments)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECSReportTaskGPU(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.ReportTaskGPU)
|
||||
}
|
||||
|
||||
// --- Capacity ---
|
||||
|
||||
func (d *Daemon) handleECSProvisionCapacity(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.ProvisionCapacity)
|
||||
}
|
||||
|
||||
// --- Tags ---
|
||||
|
||||
func (d *Daemon) handleECSTagResource(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.TagResource)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECSUntagResource(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.UntagResource)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECSListTagsForResource(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.ListTagsForResource)
|
||||
}
|
||||
|
||||
// --- Capacity providers ---
|
||||
|
||||
func (d *Daemon) handleECSPutClusterCapacityProviders(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.PutClusterCapacityProviders)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECSCreateCapacityProvider(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.CreateCapacityProvider)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECSDescribeCapacityProviders(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.DescribeCapacityProviders)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleECSDeleteCapacityProvider(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.ecsService.DeleteCapacityProvider)
|
||||
}
|
||||
@@ -1,27 +0,0 @@
|
||||
package daemon
|
||||
|
||||
import "github.com/nats-io/nats.go"
|
||||
|
||||
func (d *Daemon) handleEC2AllocateAddress(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eipService.AllocateAddress)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2ReleaseAddress(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eipService.ReleaseAddress)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2AssociateAddress(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eipService.AssociateAddress)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DisassociateAddress(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eipService.DisassociateAddress)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DescribeAddresses(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eipService.DescribeAddresses)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DescribeAddressesAttribute(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eipService.DescribeAddressesAttribute)
|
||||
}
|
||||
@@ -1,167 +0,0 @@
|
||||
package daemon
|
||||
|
||||
import "github.com/nats-io/nats.go"
|
||||
|
||||
// --- Cluster ---
|
||||
|
||||
func (d *Daemon) handleEKSCreateCluster(msg *nats.Msg) {
|
||||
handleNATSRequestWithPrincipal(msg, d.eksService.CreateCluster)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEKSDescribeCluster(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.DescribeCluster)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEKSListClusters(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.ListClusters)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEKSUpdateClusterConfig(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.UpdateClusterConfig)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEKSUpdateClusterVersion(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.UpdateClusterVersion)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEKSDeleteCluster(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.DeleteCluster)
|
||||
}
|
||||
|
||||
// --- Nodegroup ---
|
||||
|
||||
func (d *Daemon) handleEKSCreateNodegroup(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.CreateNodegroup)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEKSDescribeNodegroup(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.DescribeNodegroup)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEKSListNodegroups(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.ListNodegroups)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEKSUpdateNodegroupConfig(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.UpdateNodegroupConfig)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEKSUpdateNodegroupVersion(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.UpdateNodegroupVersion)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEKSDeleteNodegroup(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.DeleteNodegroup)
|
||||
}
|
||||
|
||||
// --- AccessEntry + AccessPolicy ---
|
||||
|
||||
func (d *Daemon) handleEKSCreateAccessEntry(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.CreateAccessEntry)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEKSDescribeAccessEntry(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.DescribeAccessEntry)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEKSListAccessEntries(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.ListAccessEntries)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEKSUpdateAccessEntry(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.UpdateAccessEntry)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEKSDeleteAccessEntry(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.DeleteAccessEntry)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEKSAssociateAccessPolicy(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.AssociateAccessPolicy)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEKSDisassociateAccessPolicy(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.DisassociateAccessPolicy)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEKSListAssociatedAccessPolicies(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.ListAssociatedAccessPolicies)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEKSListAccessPolicies(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.ListAccessPolicies)
|
||||
}
|
||||
|
||||
// --- Addons ---
|
||||
|
||||
func (d *Daemon) handleEKSListAddons(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.ListAddons)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEKSDescribeAddonVersions(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.DescribeAddonVersions)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEKSCreateAddon(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.CreateAddon)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEKSDeleteAddon(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.DeleteAddon)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEKSDescribeAddon(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.DescribeAddon)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEKSUpdateAddon(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.UpdateAddon)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEKSListStagedAddonManifests(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.ListStagedAddonManifests)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEKSGetRecoveryDirective(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.GetRecoveryDirective)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEKSSetRecoveryDirective(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.SetRecoveryDirective)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEKSRestoreSnapshot(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.RestoreSnapshot)
|
||||
}
|
||||
|
||||
// --- OIDC identity-provider configs ---
|
||||
|
||||
func (d *Daemon) handleEKSAssociateIdentityProviderConfig(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.AssociateIdentityProviderConfig)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEKSDescribeIdentityProviderConfig(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.DescribeIdentityProviderConfig)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEKSListIdentityProviderConfigs(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.ListIdentityProviderConfigs)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEKSDisassociateIdentityProviderConfig(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.DisassociateIdentityProviderConfig)
|
||||
}
|
||||
|
||||
// --- Tags ---
|
||||
|
||||
func (d *Daemon) handleEKSTagResource(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.TagResource)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEKSUntagResource(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.UntagResource)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEKSListTagsForResource(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eksService.ListTagsForResource)
|
||||
}
|
||||
@@ -71,39 +71,39 @@ func TestDaemonHandleEKS_AllHandlersDispatchToService(t *testing.T) {
|
||||
handler nats.MsgHandler
|
||||
wantCode string
|
||||
}{
|
||||
{"eks.UpdateClusterConfig", d.handleEKSUpdateClusterConfig, notImpl},
|
||||
{"eks.UpdateClusterVersion", d.handleEKSUpdateClusterVersion, notImpl},
|
||||
{"eks.CreateNodegroup", d.handleEKSCreateNodegroup, unavailable},
|
||||
{"eks.DescribeNodegroup", d.handleEKSDescribeNodegroup, invalid},
|
||||
{"eks.ListNodegroups", d.handleEKSListNodegroups, invalid},
|
||||
{"eks.UpdateNodegroupConfig", d.handleEKSUpdateNodegroupConfig, unavailable},
|
||||
{"eks.UpdateNodegroupVersion", d.handleEKSUpdateNodegroupVersion, notImpl},
|
||||
{"eks.DeleteNodegroup", d.handleEKSDeleteNodegroup, unavailable},
|
||||
{"eks.CreateAccessEntry", d.handleEKSCreateAccessEntry, invalid},
|
||||
{"eks.DescribeAccessEntry", d.handleEKSDescribeAccessEntry, invalid},
|
||||
{"eks.ListAccessEntries", d.handleEKSListAccessEntries, invalid},
|
||||
{"eks.UpdateAccessEntry", d.handleEKSUpdateAccessEntry, invalid},
|
||||
{"eks.DeleteAccessEntry", d.handleEKSDeleteAccessEntry, invalid},
|
||||
{"eks.AssociateAccessPolicy", d.handleEKSAssociateAccessPolicy, invalid},
|
||||
{"eks.DisassociateAccessPolicy", d.handleEKSDisassociateAccessPolicy, invalid},
|
||||
{"eks.ListAssociatedAccessPolicies", d.handleEKSListAssociatedAccessPolicies, invalid},
|
||||
{"eks.ListAccessPolicies", d.handleEKSListAccessPolicies, ""},
|
||||
{"eks.UpdateClusterConfig", handleNATSRequest(d.eksService.UpdateClusterConfig), notImpl},
|
||||
{"eks.UpdateClusterVersion", handleNATSRequest(d.eksService.UpdateClusterVersion), notImpl},
|
||||
{"eks.CreateNodegroup", handleNATSRequest(d.eksService.CreateNodegroup), unavailable},
|
||||
{"eks.DescribeNodegroup", handleNATSRequest(d.eksService.DescribeNodegroup), invalid},
|
||||
{"eks.ListNodegroups", handleNATSRequest(d.eksService.ListNodegroups), invalid},
|
||||
{"eks.UpdateNodegroupConfig", handleNATSRequest(d.eksService.UpdateNodegroupConfig), unavailable},
|
||||
{"eks.UpdateNodegroupVersion", handleNATSRequest(d.eksService.UpdateNodegroupVersion), notImpl},
|
||||
{"eks.DeleteNodegroup", handleNATSRequest(d.eksService.DeleteNodegroup), unavailable},
|
||||
{"eks.CreateAccessEntry", handleNATSRequest(d.eksService.CreateAccessEntry), invalid},
|
||||
{"eks.DescribeAccessEntry", handleNATSRequest(d.eksService.DescribeAccessEntry), invalid},
|
||||
{"eks.ListAccessEntries", handleNATSRequest(d.eksService.ListAccessEntries), invalid},
|
||||
{"eks.UpdateAccessEntry", handleNATSRequest(d.eksService.UpdateAccessEntry), invalid},
|
||||
{"eks.DeleteAccessEntry", handleNATSRequest(d.eksService.DeleteAccessEntry), invalid},
|
||||
{"eks.AssociateAccessPolicy", handleNATSRequest(d.eksService.AssociateAccessPolicy), invalid},
|
||||
{"eks.DisassociateAccessPolicy", handleNATSRequest(d.eksService.DisassociateAccessPolicy), invalid},
|
||||
{"eks.ListAssociatedAccessPolicies", handleNATSRequest(d.eksService.ListAssociatedAccessPolicies), invalid},
|
||||
{"eks.ListAccessPolicies", handleNATSRequest(d.eksService.ListAccessPolicies), ""},
|
||||
// Addon handlers are implemented (Sprint 6 P1): an empty body fails
|
||||
// cluster validation with InvalidParameterValue, except
|
||||
// DescribeAddonVersions which returns the static catalogue (success).
|
||||
{"eks.ListAddons", d.handleEKSListAddons, invalid},
|
||||
{"eks.DescribeAddonVersions", d.handleEKSDescribeAddonVersions, ""},
|
||||
{"eks.CreateAddon", d.handleEKSCreateAddon, invalid},
|
||||
{"eks.DeleteAddon", d.handleEKSDeleteAddon, invalid},
|
||||
{"eks.DescribeAddon", d.handleEKSDescribeAddon, invalid},
|
||||
{"eks.UpdateAddon", d.handleEKSUpdateAddon, invalid},
|
||||
{"eks.AssociateIdentityProviderConfig", d.handleEKSAssociateIdentityProviderConfig, notImpl},
|
||||
{"eks.DescribeIdentityProviderConfig", d.handleEKSDescribeIdentityProviderConfig, notImpl},
|
||||
{"eks.ListIdentityProviderConfigs", d.handleEKSListIdentityProviderConfigs, notImpl},
|
||||
{"eks.DisassociateIdentityProviderConfig", d.handleEKSDisassociateIdentityProviderConfig, notImpl},
|
||||
{"eks.TagResource", d.handleEKSTagResource, notImpl},
|
||||
{"eks.UntagResource", d.handleEKSUntagResource, notImpl},
|
||||
{"eks.ListTagsForResource", d.handleEKSListTagsForResource, notImpl},
|
||||
{"eks.ListAddons", handleNATSRequest(d.eksService.ListAddons), invalid},
|
||||
{"eks.DescribeAddonVersions", handleNATSRequest(d.eksService.DescribeAddonVersions), ""},
|
||||
{"eks.CreateAddon", handleNATSRequest(d.eksService.CreateAddon), invalid},
|
||||
{"eks.DeleteAddon", handleNATSRequest(d.eksService.DeleteAddon), invalid},
|
||||
{"eks.DescribeAddon", handleNATSRequest(d.eksService.DescribeAddon), invalid},
|
||||
{"eks.UpdateAddon", handleNATSRequest(d.eksService.UpdateAddon), invalid},
|
||||
{"eks.AssociateIdentityProviderConfig", handleNATSRequest(d.eksService.AssociateIdentityProviderConfig), notImpl},
|
||||
{"eks.DescribeIdentityProviderConfig", handleNATSRequest(d.eksService.DescribeIdentityProviderConfig), notImpl},
|
||||
{"eks.ListIdentityProviderConfigs", handleNATSRequest(d.eksService.ListIdentityProviderConfigs), notImpl},
|
||||
{"eks.DisassociateIdentityProviderConfig", handleNATSRequest(d.eksService.DisassociateIdentityProviderConfig), notImpl},
|
||||
{"eks.TagResource", handleNATSRequest(d.eksService.TagResource), notImpl},
|
||||
{"eks.UntagResource", handleNATSRequest(d.eksService.UntagResource), notImpl},
|
||||
{"eks.ListTagsForResource", handleNATSRequest(d.eksService.ListTagsForResource), notImpl},
|
||||
}
|
||||
require.Len(t, cases, 30, "expected exactly one handler per non-lifecycle AWS EKS action")
|
||||
|
||||
|
||||
@@ -1,143 +0,0 @@
|
||||
package daemon
|
||||
|
||||
import "github.com/nats-io/nats.go"
|
||||
|
||||
func (d *Daemon) handleELBv2CreateLoadBalancer(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.CreateLoadBalancer)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2DeleteLoadBalancer(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.DeleteLoadBalancer)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2DescribeLoadBalancers(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.DescribeLoadBalancers)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2CreateTargetGroup(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.CreateTargetGroup)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2ModifyTargetGroup(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.ModifyTargetGroup)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2DeleteTargetGroup(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.DeleteTargetGroup)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2DescribeTargetGroups(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.DescribeTargetGroups)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2RegisterTargets(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.RegisterTargets)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2DeregisterTargets(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.DeregisterTargets)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2DescribeTargetHealth(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.DescribeTargetHealth)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2CreateListener(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.CreateListener)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2DeleteListener(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.DeleteListener)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2ModifyListener(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.ModifyListener)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2DescribeListeners(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.DescribeListeners)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2CreateRule(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.CreateRule)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2ModifyRule(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.ModifyRule)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2DeleteRule(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.DeleteRule)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2DescribeRules(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.DescribeRules)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2SetRulePriorities(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.SetRulePriorities)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2DescribeTags(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.DescribeTags)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2AddTags(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.AddTags)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2RemoveTags(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.RemoveTags)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2LBAgentHeartbeat(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.LBAgentHeartbeat)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2GetLBConfig(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.GetLBConfig)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2ModifyTargetGroupAttributes(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.ModifyTargetGroupAttributes)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2DescribeTargetGroupAttributes(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.DescribeTargetGroupAttributes)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2ModifyLoadBalancerAttributes(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.ModifyLoadBalancerAttributes)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2DescribeLoadBalancerAttributes(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.DescribeLoadBalancerAttributes)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2SetSecurityGroups(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.SetSecurityGroups)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2SetIpAddressType(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.SetIpAddressType)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2SetSubnets(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.SetSubnets)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2AddListenerCertificates(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.AddListenerCertificates)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2RemoveListenerCertificates(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.RemoveListenerCertificates)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2DescribeListenerCertificates(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.DescribeListenerCertificates)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleELBv2DescribeSSLPolicies(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.elbv2Service.DescribeSSLPolicies)
|
||||
}
|
||||
@@ -20,24 +20,3 @@ func (d *Daemon) handleAssociateIamInstanceProfile(ctx context.Context, msg *nat
|
||||
}
|
||||
respondWithJSON(msg, result)
|
||||
}
|
||||
|
||||
// handleIamProfileDisassociate services the disassociate fan-out. The owning
|
||||
// daemon responds with the mutated association; non-owners respond with JSON
|
||||
// null so the gateway's expectedNodes collector can exit early.
|
||||
func (d *Daemon) handleIamProfileDisassociate(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.instanceService.DisassociateIamProfileAssociation)
|
||||
}
|
||||
|
||||
// handleIamProfileReplace services the replace fan-out. Same contract as
|
||||
// handleIamProfileDisassociate: every daemon responds (JSON null on
|
||||
// non-owners) so the gateway collector can exit early.
|
||||
func (d *Daemon) handleIamProfileReplace(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.instanceService.ReplaceIamProfileAssociation)
|
||||
}
|
||||
|
||||
// handleIamProfileDescribe services the describe fan-out. An empty slice is a
|
||||
// valid response (no matches on this daemon) and counts toward the gateway's
|
||||
// expectedNodes collector; the gateway concatenates per-daemon slices.
|
||||
func (d *Daemon) handleIamProfileDescribe(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.instanceService.DescribeIamProfileAssociations)
|
||||
}
|
||||
|
||||
@@ -1,37 +0,0 @@
|
||||
package daemon
|
||||
|
||||
import (
|
||||
"github.com/nats-io/nats.go"
|
||||
)
|
||||
|
||||
func (d *Daemon) handleEC2CreateInternetGateway(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.igwService.CreateInternetGateway)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DeleteInternetGateway(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.igwService.DeleteInternetGateway)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DescribeInternetGateways(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.igwService.DescribeInternetGateways)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2AttachInternetGateway(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.igwService.AttachInternetGateway)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DetachInternetGateway(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.igwService.DetachInternetGateway)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2CreateEgressOnlyInternetGateway(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eigwService.CreateEgressOnlyInternetGateway)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DeleteEgressOnlyInternetGateway(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eigwService.DeleteEgressOnlyInternetGateway)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DescribeEgressOnlyInternetGateways(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.eigwService.DescribeEgressOnlyInternetGateways)
|
||||
}
|
||||
@@ -14,34 +14,6 @@ import (
|
||||
"github.com/nats-io/nats.go"
|
||||
)
|
||||
|
||||
func (d *Daemon) handleEC2DescribeImages(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.imageService.DescribeImages)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DeregisterImage(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.imageService.DeregisterImage)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2RegisterImage(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.imageService.RegisterImage)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2CopyImage(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.imageService.CopyImage)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DescribeImageAttribute(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.imageService.DescribeImageAttribute)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2ModifyImageAttribute(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.imageService.ModifyImageAttribute)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2ResetImageAttribute(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.imageService.ResetImageAttribute)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleSpinifexPromoteImage(msg *nats.Msg) {
|
||||
promoteImage := func(_ context.Context, input *admin.PromoteImageOpts, _ string) (*admin.PromoteImageResult, error) {
|
||||
store := objectstore.NewS3ObjectStoreFromConfig(
|
||||
@@ -52,7 +24,7 @@ func (d *Daemon) handleSpinifexPromoteImage(msg *nats.Msg) {
|
||||
)
|
||||
return admin.PromoteSystemImage(store, d.config.Predastore.Bucket, *input)
|
||||
}
|
||||
handleNATSRequest(msg, promoteImage)
|
||||
handleNATSRequest(promoteImage)(msg)
|
||||
}
|
||||
|
||||
// handleEC2CreateImage is a stateful handler that extracts instance context
|
||||
|
||||
@@ -478,16 +478,6 @@ func (d *Daemon) handleEC2DescribeInstances(msg *nats.Msg) {
|
||||
slog.Info("handleEC2DescribeInstances completed", "count", len(reservations))
|
||||
}
|
||||
|
||||
// handleEC2DescribeInstanceTypes responds with instance types provisionable on this node.
|
||||
func (d *Daemon) handleEC2DescribeInstanceTypes(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.instanceService.DescribeInstanceTypes)
|
||||
}
|
||||
|
||||
// handleEC2DescribeInstanceStatus responds with status entries for VMs on this node visible to the caller.
|
||||
func (d *Daemon) handleEC2DescribeInstanceStatus(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.instanceService.DescribeInstanceStatus)
|
||||
}
|
||||
|
||||
// handleEC2StartStoppedInstance handles the generic ec2.start queue-group topic.
|
||||
// It reads the stopped instance's LastNode from shared KV and forwards the
|
||||
// request to ec2.start.{lastNode} to keep instances on their original node.
|
||||
@@ -504,7 +494,7 @@ func (d *Daemon) handleEC2StartStoppedInstance(msg *nats.Msg) {
|
||||
if err := json.Unmarshal(msg.Data, &peek); err != nil || peek.InstanceID == "" {
|
||||
// Can't determine target node — fall through to local start which will
|
||||
// return the appropriate error (missing parameter / unmarshal failure).
|
||||
handleNATSRequest(msg, d.instanceService.StartStoppedInstance)
|
||||
handleNATSRequest(d.instanceService.StartStoppedInstance)(msg)
|
||||
return
|
||||
}
|
||||
|
||||
@@ -550,19 +540,7 @@ func (d *Daemon) handleEC2StartStoppedInstance(msg *nats.Msg) {
|
||||
}
|
||||
}
|
||||
|
||||
handleNATSRequest(msg, d.instanceService.StartStoppedInstance)
|
||||
}
|
||||
|
||||
// handleEC2StartStoppedInstanceDirect handles ec2.start.{nodeId} — the
|
||||
// node-targeted topic used by handleEC2StartStoppedInstance to forward start
|
||||
// requests back to the original node. Always starts locally; never forwards
|
||||
// further, preventing routing loops.
|
||||
func (d *Daemon) handleEC2StartStoppedInstanceDirect(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.instanceService.StartStoppedInstance)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2TerminateStoppedInstance(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.instanceService.TerminateStoppedInstance)
|
||||
handleNATSRequest(d.instanceService.StartStoppedInstance)(msg)
|
||||
}
|
||||
|
||||
// handleEC2DescribeStoppedInstances returns stopped instances from shared KV.
|
||||
@@ -684,16 +662,3 @@ func (d *Daemon) describeInstancesFromKV(msg *nats.Msg, listFn func() ([]*vm.VM,
|
||||
respondWithJSON(msg, &ec2.DescribeInstancesOutput{Reservations: reservations})
|
||||
slog.Info(handlerName+" completed", "count", len(reservations))
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2ModifyInstanceAttribute(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.instanceService.ModifyInstanceAttribute)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2ModifyInstanceMetadataOptions(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.instanceService.ModifyInstanceMetadataOptions)
|
||||
}
|
||||
|
||||
// handleEC2DescribeInstanceAttribute returns a single requested attribute for an instance.
|
||||
func (d *Daemon) handleEC2DescribeInstanceAttribute(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.instanceService.DescribeInstanceAttribute)
|
||||
}
|
||||
|
||||
@@ -391,7 +391,7 @@ func TestHandleEC2TerminateStoppedInstance_LoadError(t *testing.T) {
|
||||
d := daemonWithFakeStateStore(t, store)
|
||||
|
||||
body, _ := json.Marshal(handlers_ec2_instance.TerminateStoppedInstanceInput{InstanceID: "i-load-fail"})
|
||||
reply := requestHandler(t, d.natsConn, "ec2.terminate.test1", d.handleEC2TerminateStoppedInstance, testAccountID, body)
|
||||
reply := requestHandler(t, d.natsConn, "ec2.terminate.test1", handleNATSRequest(d.instanceService.TerminateStoppedInstance), testAccountID, body)
|
||||
assert.Equal(t, awserrors.ErrorServerInternal, decodeError(t, reply.Data)["Code"])
|
||||
}
|
||||
|
||||
@@ -399,7 +399,7 @@ func TestHandleEC2TerminateStoppedInstance_StateStoreNil(t *testing.T) {
|
||||
d := createTestDaemon(t, sharedNATSURL)
|
||||
|
||||
body, _ := json.Marshal(handlers_ec2_instance.TerminateStoppedInstanceInput{InstanceID: "i-no-store"})
|
||||
reply := requestHandler(t, d.natsConn, "ec2.terminate.test2", d.handleEC2TerminateStoppedInstance, testAccountID, body)
|
||||
reply := requestHandler(t, d.natsConn, "ec2.terminate.test2", handleNATSRequest(d.instanceService.TerminateStoppedInstance), testAccountID, body)
|
||||
assert.Equal(t, awserrors.ErrorServerInternal, decodeError(t, reply.Data)["Code"])
|
||||
}
|
||||
|
||||
@@ -413,7 +413,7 @@ func TestHandleEC2TerminateStoppedInstance_WriteTerminatedFailureAborts(t *testi
|
||||
d := daemonWithFakeStateStore(t, store)
|
||||
|
||||
body, _ := json.Marshal(handlers_ec2_instance.TerminateStoppedInstanceInput{InstanceID: v.ID})
|
||||
reply := requestHandler(t, d.natsConn, "ec2.terminate.test3", d.handleEC2TerminateStoppedInstance, testAccountID, body)
|
||||
reply := requestHandler(t, d.natsConn, "ec2.terminate.test3", handleNATSRequest(d.instanceService.TerminateStoppedInstance), testAccountID, body)
|
||||
assert.Equal(t, awserrors.ErrorServerInternal, decodeError(t, reply.Data)["Code"])
|
||||
|
||||
store.mu.Lock()
|
||||
@@ -436,7 +436,7 @@ func TestHandleEC2TerminateStoppedInstance_DeleteRetrySucceeds(t *testing.T) {
|
||||
d := daemonWithFakeStateStore(t, store)
|
||||
|
||||
body, _ := json.Marshal(handlers_ec2_instance.TerminateStoppedInstanceInput{InstanceID: v.ID})
|
||||
reply := requestHandler(t, d.natsConn, "ec2.terminate.test4", d.handleEC2TerminateStoppedInstance, testAccountID, body)
|
||||
reply := requestHandler(t, d.natsConn, "ec2.terminate.test4", handleNATSRequest(d.instanceService.TerminateStoppedInstance), testAccountID, body)
|
||||
|
||||
var resp map[string]string
|
||||
require.NoError(t, json.Unmarshal(reply.Data, &resp))
|
||||
@@ -463,7 +463,7 @@ func TestHandleEC2TerminateStoppedInstance_DeleteAlwaysFailsKeepsTerminated(t *t
|
||||
d := daemonWithFakeStateStore(t, store)
|
||||
|
||||
body, _ := json.Marshal(handlers_ec2_instance.TerminateStoppedInstanceInput{InstanceID: v.ID})
|
||||
reply := requestHandler(t, d.natsConn, "ec2.terminate.test5", d.handleEC2TerminateStoppedInstance, testAccountID, body)
|
||||
reply := requestHandler(t, d.natsConn, "ec2.terminate.test5", handleNATSRequest(d.instanceService.TerminateStoppedInstance), testAccountID, body)
|
||||
|
||||
var resp map[string]string
|
||||
require.NoError(t, json.Unmarshal(reply.Data, &resp))
|
||||
@@ -481,7 +481,7 @@ func TestHandleEC2TerminateStoppedInstance_CrossTenantRejected(t *testing.T) {
|
||||
d := daemonWithFakeStateStore(t, store)
|
||||
|
||||
body, _ := json.Marshal(handlers_ec2_instance.TerminateStoppedInstanceInput{InstanceID: "i-foreign-term"})
|
||||
reply := requestHandler(t, d.natsConn, "ec2.terminate.test6", d.handleEC2TerminateStoppedInstance, testAccountID, body)
|
||||
reply := requestHandler(t, d.natsConn, "ec2.terminate.test6", handleNATSRequest(d.instanceService.TerminateStoppedInstance), testAccountID, body)
|
||||
assert.Equal(t, awserrors.ErrorInvalidInstanceIDNotFound, decodeError(t, reply.Data)["Code"])
|
||||
|
||||
store.mu.Lock()
|
||||
@@ -506,7 +506,7 @@ func TestHandleEC2ModifyInstanceAttribute_WriteFailureReturnsServerInternal(t *t
|
||||
InstanceType: &ec2.AttributeValue{Value: aws.String("t3.large")},
|
||||
}
|
||||
body, _ := json.Marshal(input)
|
||||
reply := requestHandler(t, d.natsConn, "ec2.ModifyInstanceAttribute.test1", d.handleEC2ModifyInstanceAttribute, testAccountID, body)
|
||||
reply := requestHandler(t, d.natsConn, "ec2.ModifyInstanceAttribute.test1", handleNATSRequest(d.instanceService.ModifyInstanceAttribute), testAccountID, body)
|
||||
assert.Equal(t, awserrors.ErrorServerInternal, decodeError(t, reply.Data)["Code"])
|
||||
}
|
||||
|
||||
@@ -520,7 +520,7 @@ func TestHandleEC2ModifyInstanceAttribute_LoadFailureReturnsServerInternal(t *te
|
||||
InstanceType: &ec2.AttributeValue{Value: aws.String("t3.large")},
|
||||
}
|
||||
body, _ := json.Marshal(input)
|
||||
reply := requestHandler(t, d.natsConn, "ec2.ModifyInstanceAttribute.test2", d.handleEC2ModifyInstanceAttribute, testAccountID, body)
|
||||
reply := requestHandler(t, d.natsConn, "ec2.ModifyInstanceAttribute.test2", handleNATSRequest(d.instanceService.ModifyInstanceAttribute), testAccountID, body)
|
||||
assert.Equal(t, awserrors.ErrorServerInternal, decodeError(t, reply.Data)["Code"])
|
||||
}
|
||||
|
||||
@@ -544,7 +544,7 @@ func TestHandleEC2ModifyInstanceAttribute_NilInstanceFieldGuard(t *testing.T) {
|
||||
InstanceType: &ec2.AttributeValue{Value: aws.String("t3.large")},
|
||||
}
|
||||
body, _ := json.Marshal(input)
|
||||
reply := requestHandler(t, d.natsConn, "ec2.ModifyInstanceAttribute.test3", d.handleEC2ModifyInstanceAttribute, testAccountID, body)
|
||||
reply := requestHandler(t, d.natsConn, "ec2.ModifyInstanceAttribute.test3", handleNATSRequest(d.instanceService.ModifyInstanceAttribute), testAccountID, body)
|
||||
assert.Equal(t, awserrors.ErrorServerInternal, decodeError(t, reply.Data)["Code"])
|
||||
}
|
||||
|
||||
@@ -559,7 +559,7 @@ func TestHandleEC2ModifyInstanceAttribute_EmptyInstanceTypeRejected(t *testing.T
|
||||
InstanceType: &ec2.AttributeValue{Value: aws.String("")},
|
||||
}
|
||||
body, _ := json.Marshal(input)
|
||||
reply := requestHandler(t, d.natsConn, "ec2.ModifyInstanceAttribute.test4", d.handleEC2ModifyInstanceAttribute, testAccountID, body)
|
||||
reply := requestHandler(t, d.natsConn, "ec2.ModifyInstanceAttribute.test4", handleNATSRequest(d.instanceService.ModifyInstanceAttribute), testAccountID, body)
|
||||
assert.Equal(t, awserrors.ErrorInvalidInstanceAttributeValue, decodeError(t, reply.Data)["Code"])
|
||||
}
|
||||
|
||||
@@ -573,7 +573,7 @@ func TestHandleEC2ModifyInstanceAttribute_CrossTenantRejected(t *testing.T) {
|
||||
InstanceType: &ec2.AttributeValue{Value: aws.String("t3.large")},
|
||||
}
|
||||
body, _ := json.Marshal(input)
|
||||
reply := requestHandler(t, d.natsConn, "ec2.ModifyInstanceAttribute.test5", d.handleEC2ModifyInstanceAttribute, testAccountID, body)
|
||||
reply := requestHandler(t, d.natsConn, "ec2.ModifyInstanceAttribute.test5", handleNATSRequest(d.instanceService.ModifyInstanceAttribute), testAccountID, body)
|
||||
assert.Equal(t, awserrors.ErrorInvalidInstanceIDNotFound, decodeError(t, reply.Data)["Code"])
|
||||
}
|
||||
|
||||
@@ -591,7 +591,7 @@ func TestHandleEC2DescribeInstanceAttribute_StoppedFallback_LoadError(t *testing
|
||||
Attribute: aws.String(ec2.InstanceAttributeNameInstanceType),
|
||||
}
|
||||
body, _ := json.Marshal(input)
|
||||
reply := requestHandler(t, d.natsConn, "ec2.DescribeInstanceAttribute.test1", d.handleEC2DescribeInstanceAttribute, testAccountID, body)
|
||||
reply := requestHandler(t, d.natsConn, "ec2.DescribeInstanceAttribute.test1", handleNATSRequest(d.instanceService.DescribeInstanceAttribute), testAccountID, body)
|
||||
assert.Equal(t, awserrors.ErrorServerInternal, decodeError(t, reply.Data)["Code"])
|
||||
}
|
||||
|
||||
@@ -608,7 +608,7 @@ func TestHandleEC2DescribeInstanceAttribute_StoppedFallback_HitsKV(t *testing.T)
|
||||
Attribute: aws.String(ec2.InstanceAttributeNameInstanceType),
|
||||
}
|
||||
body, _ := json.Marshal(input)
|
||||
reply := requestHandler(t, d.natsConn, "ec2.DescribeInstanceAttribute.test2", d.handleEC2DescribeInstanceAttribute, testAccountID, body)
|
||||
reply := requestHandler(t, d.natsConn, "ec2.DescribeInstanceAttribute.test2", handleNATSRequest(d.instanceService.DescribeInstanceAttribute), testAccountID, body)
|
||||
|
||||
var output ec2.DescribeInstanceAttributeOutput
|
||||
require.NoError(t, json.Unmarshal(reply.Data, &output))
|
||||
@@ -627,7 +627,7 @@ func TestHandleEC2DescribeInstanceAttribute_StateStoreNil(t *testing.T) {
|
||||
Attribute: aws.String(ec2.InstanceAttributeNameInstanceType),
|
||||
}
|
||||
body, _ := json.Marshal(input)
|
||||
reply := requestHandler(t, d.natsConn, "ec2.DescribeInstanceAttribute.test3", d.handleEC2DescribeInstanceAttribute, testAccountID, body)
|
||||
reply := requestHandler(t, d.natsConn, "ec2.DescribeInstanceAttribute.test3", handleNATSRequest(d.instanceService.DescribeInstanceAttribute), testAccountID, body)
|
||||
assert.Equal(t, awserrors.ErrorServerInternal, decodeError(t, reply.Data)["Code"])
|
||||
}
|
||||
|
||||
|
||||
@@ -6,22 +6,6 @@ import (
|
||||
"github.com/nats-io/nats.go"
|
||||
)
|
||||
|
||||
func (d *Daemon) handleEC2CreateKeyPair(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.keyService.CreateKeyPair)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DeleteKeyPair(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.keyService.DeleteKeyPair)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DescribeKeyPairs(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.keyService.DescribeKeyPairs)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2ImportKeyPair(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.keyService.ImportKeyPair)
|
||||
}
|
||||
|
||||
// handleIMDSGetPublicKey answers the IMDS material-path RPC. The responder lives
|
||||
// here (not in vpcd) because the daemon holds the key service and its Predastore
|
||||
// credentials; vpcd carries only a nats.Conn.
|
||||
|
||||
@@ -1,31 +0,0 @@
|
||||
package daemon
|
||||
|
||||
import "github.com/nats-io/nats.go"
|
||||
|
||||
func (d *Daemon) handleEC2CreateLaunchTemplate(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.launchTemplateService.CreateLaunchTemplate)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2CreateLaunchTemplateVersion(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.launchTemplateService.CreateLaunchTemplateVersion)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DeleteLaunchTemplate(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.launchTemplateService.DeleteLaunchTemplate)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DeleteLaunchTemplateVersions(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.launchTemplateService.DeleteLaunchTemplateVersions)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2ModifyLaunchTemplate(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.launchTemplateService.ModifyLaunchTemplate)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DescribeLaunchTemplates(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.launchTemplateService.DescribeLaunchTemplates)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DescribeLaunchTemplateVersions(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.launchTemplateService.DescribeLaunchTemplateVersions)
|
||||
}
|
||||
@@ -1,17 +0,0 @@
|
||||
package daemon
|
||||
|
||||
import (
|
||||
"github.com/nats-io/nats.go"
|
||||
)
|
||||
|
||||
func (d *Daemon) handleEC2CreateNatGateway(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.natGatewayService.CreateNatGateway)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DeleteNatGateway(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.natGatewayService.DeleteNatGateway)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DescribeNatGateways(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.natGatewayService.DescribeNatGateways)
|
||||
}
|
||||
@@ -1,39 +0,0 @@
|
||||
package daemon
|
||||
|
||||
import "github.com/nats-io/nats.go"
|
||||
|
||||
func (d *Daemon) handleEC2CreatePlacementGroup(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.placementGroupService.CreatePlacementGroup)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DeletePlacementGroup(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.placementGroupService.DeletePlacementGroup)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DescribePlacementGroups(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.placementGroupService.DescribePlacementGroups)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2ReserveSpreadNodes(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.placementGroupService.ReserveSpreadNodes)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2FinalizeSpreadInstances(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.placementGroupService.FinalizeSpreadInstances)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2ReleaseSpreadNodes(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.placementGroupService.ReleaseSpreadNodes)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2RemoveInstanceFromPlacementGroup(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.placementGroupService.RemoveInstance)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2ReserveClusterNode(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.placementGroupService.ReserveClusterNode)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2FinalizeClusterInstances(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.placementGroupService.FinalizeClusterInstances)
|
||||
}
|
||||
@@ -1,41 +0,0 @@
|
||||
package daemon
|
||||
|
||||
import (
|
||||
"github.com/nats-io/nats.go"
|
||||
)
|
||||
|
||||
func (d *Daemon) handleEC2CreateRouteTable(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.routeTableService.CreateRouteTable)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DeleteRouteTable(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.routeTableService.DeleteRouteTable)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DescribeRouteTables(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.routeTableService.DescribeRouteTables)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2CreateRoute(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.routeTableService.CreateRoute)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DeleteRoute(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.routeTableService.DeleteRoute)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2ReplaceRoute(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.routeTableService.ReplaceRoute)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2AssociateRouteTable(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.routeTableService.AssociateRouteTable)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DisassociateRouteTable(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.routeTableService.DisassociateRouteTable)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2ReplaceRouteTableAssociation(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.routeTableService.ReplaceRouteTableAssociation)
|
||||
}
|
||||
@@ -1,35 +0,0 @@
|
||||
package daemon
|
||||
|
||||
import "github.com/nats-io/nats.go"
|
||||
|
||||
func (d *Daemon) handleEC2CreateSecurityGroup(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.vpcService.CreateSecurityGroup)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DeleteSecurityGroup(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.vpcService.DeleteSecurityGroup)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DescribeSecurityGroups(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.vpcService.DescribeSecurityGroups)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DescribeSecurityGroupRules(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.vpcService.DescribeSecurityGroupRules)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2AuthorizeSecurityGroupIngress(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.vpcService.AuthorizeSecurityGroupIngress)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2AuthorizeSecurityGroupEgress(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.vpcService.AuthorizeSecurityGroupEgress)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2RevokeSecurityGroupIngress(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.vpcService.RevokeSecurityGroupIngress)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2RevokeSecurityGroupEgress(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.vpcService.RevokeSecurityGroupEgress)
|
||||
}
|
||||
@@ -1,21 +0,0 @@
|
||||
package daemon
|
||||
|
||||
import (
|
||||
"github.com/nats-io/nats.go"
|
||||
)
|
||||
|
||||
func (d *Daemon) handleEC2CreateSnapshot(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.snapshotService.CreateSnapshot)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DescribeSnapshots(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.snapshotService.DescribeSnapshots)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DeleteSnapshot(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.snapshotService.DeleteSnapshot)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2CopySnapshot(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.snapshotService.CopySnapshot)
|
||||
}
|
||||
@@ -11,18 +11,6 @@ import (
|
||||
"github.com/nats-io/nats.go"
|
||||
)
|
||||
|
||||
func (d *Daemon) handleEC2PutSpotInstanceRequests(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.spotInstanceService.PutSpotInstanceRequests)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DescribeSpotInstanceRequests(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.spotInstanceService.DescribeSpotInstanceRequests)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2CancelSpotInstanceRequests(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.spotInstanceService.CancelSpotInstanceRequests)
|
||||
}
|
||||
|
||||
// handleSetSpotLineage stamps the spot lineage (InstanceLifecycle=spot +
|
||||
// SpotInstanceRequestId) onto a launched VM. Dispatched from handleEC2Events,
|
||||
// which already verified ownership; the SIR id is the only datum on the wire as
|
||||
|
||||
@@ -21,18 +21,6 @@ import (
|
||||
// only a partitioned-but-subscribed owner pays the full timeout.
|
||||
const instanceTagCommandTimeout = 5 * time.Second
|
||||
|
||||
func (d *Daemon) handleEC2CreateTags(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.createTags)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DeleteTags(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.deleteTags)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DescribeTags(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.tagsService.DescribeTags)
|
||||
}
|
||||
|
||||
// recordTagMirror is implemented by every service whose resource records
|
||||
// mirror the central tag store, so tag-filtered describes observe tags
|
||||
// written through create-tags/delete-tags.
|
||||
|
||||
@@ -157,9 +157,7 @@ func TestHandleNATSRequest_ValidRequest(t *testing.T) {
|
||||
return &testOutput{Greeting: "hello " + in.Name}, nil
|
||||
}
|
||||
|
||||
sub, err := nc.Subscribe("test.greet", func(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, serviceFn)
|
||||
})
|
||||
sub, err := nc.Subscribe("test.greet", handleNATSRequest(serviceFn))
|
||||
require.NoError(t, err)
|
||||
defer sub.Unsubscribe()
|
||||
|
||||
@@ -184,9 +182,7 @@ func TestHandleNATSRequest_MalformedJSON(t *testing.T) {
|
||||
return &testOutput{Greeting: "hello"}, nil
|
||||
}
|
||||
|
||||
sub, err := nc.Subscribe("test.malformed", func(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, serviceFn)
|
||||
})
|
||||
sub, err := nc.Subscribe("test.malformed", handleNATSRequest(serviceFn))
|
||||
require.NoError(t, err)
|
||||
defer sub.Unsubscribe()
|
||||
|
||||
@@ -210,9 +206,7 @@ func TestHandleNATSRequest_ServiceError(t *testing.T) {
|
||||
return nil, fmt.Errorf("something went wrong")
|
||||
}
|
||||
|
||||
sub, err := nc.Subscribe("test.err", func(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, serviceFn)
|
||||
})
|
||||
sub, err := nc.Subscribe("test.err", handleNATSRequest(serviceFn))
|
||||
require.NoError(t, err)
|
||||
defer sub.Unsubscribe()
|
||||
|
||||
@@ -235,7 +229,7 @@ func TestHandleEC2CreateKeyPair_RoundTrip(t *testing.T) {
|
||||
|
||||
daemon := createFullTestDaemon(t, natsURL)
|
||||
|
||||
sub, err := daemon.natsConn.QueueSubscribe("ec2.CreateKeyPair", "spinifex-workers", daemon.handleEC2CreateKeyPair)
|
||||
sub, err := daemon.natsConn.QueueSubscribe("ec2.CreateKeyPair", "spinifex-workers", handleNATSRequest(daemon.keyService.CreateKeyPair))
|
||||
require.NoError(t, err)
|
||||
defer sub.Unsubscribe()
|
||||
|
||||
@@ -1510,7 +1504,7 @@ func TestHandleEC2ModifyInstanceAttribute_WrapperRoundTrip(t *testing.T) {
|
||||
|
||||
daemon := createFullTestDaemonWithJetStream(t, natsURL)
|
||||
|
||||
sub, err := daemon.natsConn.QueueSubscribe("ec2.ModifyInstanceAttribute", "spinifex-workers", daemon.handleEC2ModifyInstanceAttribute)
|
||||
sub, err := daemon.natsConn.QueueSubscribe("ec2.ModifyInstanceAttribute", "spinifex-workers", handleNATSRequest(daemon.instanceService.ModifyInstanceAttribute))
|
||||
require.NoError(t, err)
|
||||
defer sub.Unsubscribe()
|
||||
|
||||
@@ -1552,7 +1546,7 @@ func TestHandleEC2DescribeInstanceAttribute_RunningInstance_InstanceType(t *test
|
||||
|
||||
daemon := createFullTestDaemonWithJetStream(t, natsURL)
|
||||
|
||||
sub, err := daemon.natsConn.Subscribe("ec2.DescribeInstanceAttribute", daemon.handleEC2DescribeInstanceAttribute)
|
||||
sub, err := daemon.natsConn.Subscribe("ec2.DescribeInstanceAttribute", handleNATSRequest(daemon.instanceService.DescribeInstanceAttribute))
|
||||
require.NoError(t, err)
|
||||
defer sub.Unsubscribe()
|
||||
|
||||
@@ -1594,7 +1588,7 @@ func TestHandleEC2DescribeInstanceAttribute_StoppedInstance_InstanceType(t *test
|
||||
|
||||
daemon := createFullTestDaemonWithJetStream(t, natsURL)
|
||||
|
||||
sub, err := daemon.natsConn.Subscribe("ec2.DescribeInstanceAttribute", daemon.handleEC2DescribeInstanceAttribute)
|
||||
sub, err := daemon.natsConn.Subscribe("ec2.DescribeInstanceAttribute", handleNATSRequest(daemon.instanceService.DescribeInstanceAttribute))
|
||||
require.NoError(t, err)
|
||||
defer sub.Unsubscribe()
|
||||
|
||||
@@ -1634,7 +1628,7 @@ func TestHandleEC2DescribeInstanceAttribute_UserData(t *testing.T) {
|
||||
|
||||
daemon := createFullTestDaemonWithJetStream(t, natsURL)
|
||||
|
||||
sub, err := daemon.natsConn.Subscribe("ec2.DescribeInstanceAttribute", daemon.handleEC2DescribeInstanceAttribute)
|
||||
sub, err := daemon.natsConn.Subscribe("ec2.DescribeInstanceAttribute", handleNATSRequest(daemon.instanceService.DescribeInstanceAttribute))
|
||||
require.NoError(t, err)
|
||||
defer sub.Unsubscribe()
|
||||
|
||||
@@ -1676,7 +1670,7 @@ func TestHandleEC2DescribeInstanceAttribute_DefaultAttribute_DisableApiTerminati
|
||||
|
||||
daemon := createFullTestDaemonWithJetStream(t, natsURL)
|
||||
|
||||
sub, err := daemon.natsConn.Subscribe("ec2.DescribeInstanceAttribute", daemon.handleEC2DescribeInstanceAttribute)
|
||||
sub, err := daemon.natsConn.Subscribe("ec2.DescribeInstanceAttribute", handleNATSRequest(daemon.instanceService.DescribeInstanceAttribute))
|
||||
require.NoError(t, err)
|
||||
defer sub.Unsubscribe()
|
||||
|
||||
@@ -1720,7 +1714,7 @@ func TestHandleEC2DescribeInstanceAttribute_DefaultAttribute_ShutdownBehavior(t
|
||||
|
||||
daemon := createFullTestDaemonWithJetStream(t, natsURL)
|
||||
|
||||
sub, err := daemon.natsConn.Subscribe("ec2.DescribeInstanceAttribute", daemon.handleEC2DescribeInstanceAttribute)
|
||||
sub, err := daemon.natsConn.Subscribe("ec2.DescribeInstanceAttribute", handleNATSRequest(daemon.instanceService.DescribeInstanceAttribute))
|
||||
require.NoError(t, err)
|
||||
defer sub.Unsubscribe()
|
||||
|
||||
@@ -1758,7 +1752,7 @@ func TestHandleEC2DescribeInstanceAttribute_GroupSet_WithSecurityGroups(t *testi
|
||||
|
||||
daemon := createFullTestDaemonWithJetStream(t, natsURL)
|
||||
|
||||
sub, err := daemon.natsConn.Subscribe("ec2.DescribeInstanceAttribute", daemon.handleEC2DescribeInstanceAttribute)
|
||||
sub, err := daemon.natsConn.Subscribe("ec2.DescribeInstanceAttribute", handleNATSRequest(daemon.instanceService.DescribeInstanceAttribute))
|
||||
require.NoError(t, err)
|
||||
defer sub.Unsubscribe()
|
||||
|
||||
@@ -1804,7 +1798,7 @@ func TestHandleEC2DescribeInstanceAttribute_GroupSet_NilInstance(t *testing.T) {
|
||||
|
||||
daemon := createFullTestDaemonWithJetStream(t, natsURL)
|
||||
|
||||
sub, err := daemon.natsConn.Subscribe("ec2.DescribeInstanceAttribute", daemon.handleEC2DescribeInstanceAttribute)
|
||||
sub, err := daemon.natsConn.Subscribe("ec2.DescribeInstanceAttribute", handleNATSRequest(daemon.instanceService.DescribeInstanceAttribute))
|
||||
require.NoError(t, err)
|
||||
defer sub.Unsubscribe()
|
||||
|
||||
@@ -1841,7 +1835,7 @@ func TestHandleEC2DescribeInstanceAttribute_InstanceNotFound(t *testing.T) {
|
||||
|
||||
daemon := createFullTestDaemonWithJetStream(t, natsURL)
|
||||
|
||||
sub, err := daemon.natsConn.Subscribe("ec2.DescribeInstanceAttribute", daemon.handleEC2DescribeInstanceAttribute)
|
||||
sub, err := daemon.natsConn.Subscribe("ec2.DescribeInstanceAttribute", handleNATSRequest(daemon.instanceService.DescribeInstanceAttribute))
|
||||
require.NoError(t, err)
|
||||
defer sub.Unsubscribe()
|
||||
|
||||
@@ -1864,7 +1858,7 @@ func TestHandleEC2DescribeInstanceAttribute_UnsupportedAttribute(t *testing.T) {
|
||||
|
||||
daemon := createFullTestDaemonWithJetStream(t, natsURL)
|
||||
|
||||
sub, err := daemon.natsConn.Subscribe("ec2.DescribeInstanceAttribute", daemon.handleEC2DescribeInstanceAttribute)
|
||||
sub, err := daemon.natsConn.Subscribe("ec2.DescribeInstanceAttribute", handleNATSRequest(daemon.instanceService.DescribeInstanceAttribute))
|
||||
require.NoError(t, err)
|
||||
defer sub.Unsubscribe()
|
||||
|
||||
@@ -1900,7 +1894,7 @@ func TestHandleEC2DescribeInstanceAttribute_InvalidJSON(t *testing.T) {
|
||||
|
||||
daemon := createFullTestDaemonWithJetStream(t, natsURL)
|
||||
|
||||
sub, err := daemon.natsConn.Subscribe("ec2.DescribeInstanceAttribute", daemon.handleEC2DescribeInstanceAttribute)
|
||||
sub, err := daemon.natsConn.Subscribe("ec2.DescribeInstanceAttribute", handleNATSRequest(daemon.instanceService.DescribeInstanceAttribute))
|
||||
require.NoError(t, err)
|
||||
defer sub.Unsubscribe()
|
||||
|
||||
@@ -1941,68 +1935,68 @@ func TestDelegateHandlers_RoundTrip(t *testing.T) {
|
||||
{
|
||||
name: "DeleteKeyPair",
|
||||
topic: "ec2.test.DeleteKeyPair",
|
||||
handler: daemon.handleEC2DeleteKeyPair,
|
||||
handler: handleNATSRequest(daemon.keyService.DeleteKeyPair),
|
||||
input: &ec2.DeleteKeyPairInput{KeyName: aws.String("nonexistent-key")},
|
||||
// Idempotent delete: missing key returns a success response.
|
||||
},
|
||||
{
|
||||
name: "ImportKeyPair",
|
||||
topic: "ec2.test.ImportKeyPair",
|
||||
handler: daemon.handleEC2ImportKeyPair,
|
||||
handler: handleNATSRequest(daemon.keyService.ImportKeyPair),
|
||||
input: &ec2.ImportKeyPairInput{KeyName: aws.String("imported-key"), PublicKeyMaterial: []byte("ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAITest test@test")},
|
||||
expectedCode: awserrors.ErrorInvalidKeyFormat,
|
||||
},
|
||||
{
|
||||
name: "CreateVolume",
|
||||
topic: "ec2.test.CreateVolume",
|
||||
handler: daemon.handleEC2CreateVolume,
|
||||
handler: handleNATSRequest(daemon.volumeService.CreateVolume),
|
||||
input: &ec2.CreateVolumeInput{AvailabilityZone: aws.String("us-east-1a"), Size: aws.Int64(10)},
|
||||
expectedCode: awserrors.ErrorInvalidAvailabilityZone,
|
||||
},
|
||||
{
|
||||
name: "DescribeVolumeStatus",
|
||||
topic: "ec2.test.DescribeVolumeStatus",
|
||||
handler: daemon.handleEC2DescribeVolumeStatus,
|
||||
handler: handleNATSRequest(daemon.volumeService.DescribeVolumeStatus),
|
||||
input: &ec2.DescribeVolumeStatusInput{},
|
||||
},
|
||||
{
|
||||
name: "DeleteVolume",
|
||||
topic: "ec2.test.DeleteVolume",
|
||||
handler: daemon.handleEC2DeleteVolume,
|
||||
handler: handleNATSRequest(daemon.volumeService.DeleteVolume),
|
||||
input: &ec2.DeleteVolumeInput{VolumeId: aws.String("vol-nonexistent")},
|
||||
expectedCode: awserrors.ErrorInvalidVolumeNotFound,
|
||||
},
|
||||
{
|
||||
name: "CreateSnapshot",
|
||||
topic: "ec2.test.CreateSnapshot",
|
||||
handler: daemon.handleEC2CreateSnapshot,
|
||||
handler: handleNATSRequest(daemon.snapshotService.CreateSnapshot),
|
||||
input: &ec2.CreateSnapshotInput{VolumeId: aws.String("vol-nonexistent")},
|
||||
expectedCode: awserrors.ErrorInvalidVolumeNotFound,
|
||||
},
|
||||
{
|
||||
name: "DescribeSnapshots",
|
||||
topic: "ec2.test.DescribeSnapshots",
|
||||
handler: daemon.handleEC2DescribeSnapshots,
|
||||
handler: handleNATSRequest(daemon.snapshotService.DescribeSnapshots),
|
||||
input: &ec2.DescribeSnapshotsInput{},
|
||||
},
|
||||
{
|
||||
name: "DeleteSnapshot",
|
||||
topic: "ec2.test.DeleteSnapshot",
|
||||
handler: daemon.handleEC2DeleteSnapshot,
|
||||
handler: handleNATSRequest(daemon.snapshotService.DeleteSnapshot),
|
||||
input: &ec2.DeleteSnapshotInput{SnapshotId: aws.String("snap-nonexistent")},
|
||||
expectedCode: awserrors.ErrorInvalidSnapshotNotFound,
|
||||
},
|
||||
{
|
||||
name: "CopySnapshot",
|
||||
topic: "ec2.test.CopySnapshot",
|
||||
handler: daemon.handleEC2CopySnapshot,
|
||||
handler: handleNATSRequest(daemon.snapshotService.CopySnapshot),
|
||||
input: &ec2.CopySnapshotInput{SourceRegion: aws.String("us-east-1"), SourceSnapshotId: aws.String("snap-nonexistent")},
|
||||
expectedCode: awserrors.ErrorInvalidSnapshotNotFound,
|
||||
},
|
||||
{
|
||||
name: "DeleteTags",
|
||||
topic: "ec2.test.DeleteTags",
|
||||
handler: daemon.handleEC2DeleteTags,
|
||||
handler: handleNATSRequest(daemon.deleteTags),
|
||||
// Instance IDs route to the owning daemon; with no owner
|
||||
// subscribed the mutation is rejected rather than written blind.
|
||||
input: &ec2.DeleteTagsInput{Resources: []*string{aws.String("i-12345678")}},
|
||||
@@ -2011,7 +2005,7 @@ func TestDelegateHandlers_RoundTrip(t *testing.T) {
|
||||
{
|
||||
name: "DescribeTags",
|
||||
topic: "ec2.test.DescribeTags",
|
||||
handler: daemon.handleEC2DescribeTags,
|
||||
handler: handleNATSRequest(daemon.tagsService.DescribeTags),
|
||||
input: &ec2.DescribeTagsInput{},
|
||||
},
|
||||
}
|
||||
@@ -2301,26 +2295,26 @@ func TestDelegateHandlers_VPC(t *testing.T) {
|
||||
{
|
||||
name: "CreateVpc",
|
||||
topic: "ec2.test.CreateVpc",
|
||||
handler: daemon.handleEC2CreateVpc,
|
||||
handler: handleNATSRequest(daemon.vpcService.CreateVpc),
|
||||
input: &ec2.CreateVpcInput{CidrBlock: aws.String("10.0.0.0/16")},
|
||||
},
|
||||
{
|
||||
name: "DeleteVpc",
|
||||
topic: "ec2.test.DeleteVpc",
|
||||
handler: daemon.handleEC2DeleteVpc,
|
||||
handler: handleNATSRequest(daemon.vpcService.DeleteVpc),
|
||||
input: &ec2.DeleteVpcInput{VpcId: aws.String("vpc-nonexistent")},
|
||||
expectedCode: awserrors.ErrorInvalidVpcIDNotFound,
|
||||
},
|
||||
{
|
||||
name: "DescribeVpcs",
|
||||
topic: "ec2.test.DescribeVpcs",
|
||||
handler: daemon.handleEC2DescribeVpcs,
|
||||
handler: handleNATSRequest(daemon.vpcService.DescribeVpcs),
|
||||
input: &ec2.DescribeVpcsInput{},
|
||||
},
|
||||
{
|
||||
name: "CreateSubnet",
|
||||
topic: "ec2.test.CreateSubnet",
|
||||
handler: daemon.handleEC2CreateSubnet,
|
||||
handler: handleNATSRequest(daemon.vpcService.CreateSubnet),
|
||||
input: &ec2.CreateSubnetInput{
|
||||
VpcId: aws.String("vpc-nonexistent"),
|
||||
CidrBlock: aws.String("10.0.1.0/24"),
|
||||
@@ -2330,34 +2324,34 @@ func TestDelegateHandlers_VPC(t *testing.T) {
|
||||
{
|
||||
name: "DeleteSubnet",
|
||||
topic: "ec2.test.DeleteSubnet",
|
||||
handler: daemon.handleEC2DeleteSubnet,
|
||||
handler: handleNATSRequest(daemon.vpcService.DeleteSubnet),
|
||||
input: &ec2.DeleteSubnetInput{SubnetId: aws.String("subnet-nonexistent")},
|
||||
expectedCode: awserrors.ErrorInvalidSubnetIDNotFound,
|
||||
},
|
||||
{
|
||||
name: "DescribeSubnets",
|
||||
topic: "ec2.test.DescribeSubnets",
|
||||
handler: daemon.handleEC2DescribeSubnets,
|
||||
handler: handleNATSRequest(daemon.vpcService.DescribeSubnets),
|
||||
input: &ec2.DescribeSubnetsInput{},
|
||||
},
|
||||
{
|
||||
name: "CreateNetworkInterface",
|
||||
topic: "ec2.test.CreateNetworkInterface",
|
||||
handler: daemon.handleEC2CreateNetworkInterface,
|
||||
handler: handleNATSRequest(daemon.vpcService.CreateNetworkInterface),
|
||||
input: &ec2.CreateNetworkInterfaceInput{SubnetId: aws.String("subnet-nonexistent")},
|
||||
expectedCode: awserrors.ErrorInvalidSubnetIDNotFound,
|
||||
},
|
||||
{
|
||||
name: "DeleteNetworkInterface",
|
||||
topic: "ec2.test.DeleteNetworkInterface",
|
||||
handler: daemon.handleEC2DeleteNetworkInterface,
|
||||
handler: handleNATSRequest(daemon.vpcService.DeleteNetworkInterface),
|
||||
input: &ec2.DeleteNetworkInterfaceInput{NetworkInterfaceId: aws.String("eni-nonexistent")},
|
||||
expectedCode: awserrors.ErrorInvalidNetworkInterfaceIDNotFound,
|
||||
},
|
||||
{
|
||||
name: "DescribeNetworkInterfaces",
|
||||
topic: "ec2.test.DescribeNetworkInterfaces",
|
||||
handler: daemon.handleEC2DescribeNetworkInterfaces,
|
||||
handler: handleNATSRequest(daemon.vpcService.DescribeNetworkInterfaces),
|
||||
input: &ec2.DescribeNetworkInterfacesInput{},
|
||||
},
|
||||
}
|
||||
@@ -2394,26 +2388,26 @@ func TestDelegateHandlers_IGW(t *testing.T) {
|
||||
{
|
||||
name: "CreateInternetGateway",
|
||||
topic: "ec2.test.CreateInternetGateway",
|
||||
handler: daemon.handleEC2CreateInternetGateway,
|
||||
handler: handleNATSRequest(daemon.igwService.CreateInternetGateway),
|
||||
input: &ec2.CreateInternetGatewayInput{},
|
||||
},
|
||||
{
|
||||
name: "DeleteInternetGateway",
|
||||
topic: "ec2.test.DeleteInternetGateway",
|
||||
handler: daemon.handleEC2DeleteInternetGateway,
|
||||
handler: handleNATSRequest(daemon.igwService.DeleteInternetGateway),
|
||||
input: &ec2.DeleteInternetGatewayInput{InternetGatewayId: aws.String("igw-nonexistent")},
|
||||
expectedCode: awserrors.ErrorInvalidInternetGatewayIDNotFound,
|
||||
},
|
||||
{
|
||||
name: "DescribeInternetGateways",
|
||||
topic: "ec2.test.DescribeInternetGateways",
|
||||
handler: daemon.handleEC2DescribeInternetGateways,
|
||||
handler: handleNATSRequest(daemon.igwService.DescribeInternetGateways),
|
||||
input: &ec2.DescribeInternetGatewaysInput{},
|
||||
},
|
||||
{
|
||||
name: "AttachInternetGateway",
|
||||
topic: "ec2.test.AttachInternetGateway",
|
||||
handler: daemon.handleEC2AttachInternetGateway,
|
||||
handler: handleNATSRequest(daemon.igwService.AttachInternetGateway),
|
||||
input: &ec2.AttachInternetGatewayInput{
|
||||
InternetGatewayId: aws.String("igw-nonexistent"),
|
||||
VpcId: aws.String("vpc-nonexistent"),
|
||||
@@ -2423,7 +2417,7 @@ func TestDelegateHandlers_IGW(t *testing.T) {
|
||||
{
|
||||
name: "DetachInternetGateway",
|
||||
topic: "ec2.test.DetachInternetGateway",
|
||||
handler: daemon.handleEC2DetachInternetGateway,
|
||||
handler: handleNATSRequest(daemon.igwService.DetachInternetGateway),
|
||||
input: &ec2.DetachInternetGatewayInput{
|
||||
InternetGatewayId: aws.String("igw-nonexistent"),
|
||||
VpcId: aws.String("vpc-nonexistent"),
|
||||
@@ -2453,7 +2447,7 @@ func TestDelegateHandlers_IGW(t *testing.T) {
|
||||
func TestHandleEC2CreateVpc_SuccessPath(t *testing.T) {
|
||||
daemon := createVPCTestDaemon(t)
|
||||
|
||||
sub, err := daemon.natsConn.QueueSubscribe("ec2.CreateVpc", "spinifex-workers", daemon.handleEC2CreateVpc)
|
||||
sub, err := daemon.natsConn.QueueSubscribe("ec2.CreateVpc", "spinifex-workers", handleNATSRequest(daemon.vpcService.CreateVpc))
|
||||
require.NoError(t, err)
|
||||
defer sub.Unsubscribe()
|
||||
|
||||
@@ -2474,11 +2468,11 @@ func TestHandleEC2CreateVpc_SuccessPath(t *testing.T) {
|
||||
func TestHandleEC2CreateAndDescribeVpc_RoundTrip(t *testing.T) {
|
||||
daemon := createVPCTestDaemon(t)
|
||||
|
||||
createSub, err := daemon.natsConn.QueueSubscribe("ec2.CreateVpc", "spinifex-workers", daemon.handleEC2CreateVpc)
|
||||
createSub, err := daemon.natsConn.QueueSubscribe("ec2.CreateVpc", "spinifex-workers", handleNATSRequest(daemon.vpcService.CreateVpc))
|
||||
require.NoError(t, err)
|
||||
defer createSub.Unsubscribe()
|
||||
|
||||
describeSub, err := daemon.natsConn.QueueSubscribe("ec2.DescribeVpcs", "spinifex-workers", daemon.handleEC2DescribeVpcs)
|
||||
describeSub, err := daemon.natsConn.QueueSubscribe("ec2.DescribeVpcs", "spinifex-workers", handleNATSRequest(daemon.vpcService.DescribeVpcs))
|
||||
require.NoError(t, err)
|
||||
defer describeSub.Unsubscribe()
|
||||
|
||||
@@ -2514,7 +2508,7 @@ func TestHandleEC2CreateAndDescribeVpc_RoundTrip(t *testing.T) {
|
||||
func TestHandleEC2CreateInternetGateway_SuccessPath(t *testing.T) {
|
||||
daemon := createVPCTestDaemon(t)
|
||||
|
||||
sub, err := daemon.natsConn.QueueSubscribe("ec2.CreateInternetGateway", "spinifex-workers", daemon.handleEC2CreateInternetGateway)
|
||||
sub, err := daemon.natsConn.QueueSubscribe("ec2.CreateInternetGateway", "spinifex-workers", handleNATSRequest(daemon.igwService.CreateInternetGateway))
|
||||
require.NoError(t, err)
|
||||
defer sub.Unsubscribe()
|
||||
|
||||
@@ -2534,11 +2528,11 @@ func TestHandleEC2CreateInternetGateway_SuccessPath(t *testing.T) {
|
||||
func TestHandleEC2CreateSubnet_SuccessPath(t *testing.T) {
|
||||
daemon := createVPCTestDaemon(t)
|
||||
|
||||
createVpcSub, err := daemon.natsConn.QueueSubscribe("ec2.CreateVpc", "spinifex-workers", daemon.handleEC2CreateVpc)
|
||||
createVpcSub, err := daemon.natsConn.QueueSubscribe("ec2.CreateVpc", "spinifex-workers", handleNATSRequest(daemon.vpcService.CreateVpc))
|
||||
require.NoError(t, err)
|
||||
defer createVpcSub.Unsubscribe()
|
||||
|
||||
createSubnetSub, err := daemon.natsConn.QueueSubscribe("ec2.CreateSubnet", "spinifex-workers", daemon.handleEC2CreateSubnet)
|
||||
createSubnetSub, err := daemon.natsConn.QueueSubscribe("ec2.CreateSubnet", "spinifex-workers", handleNATSRequest(daemon.vpcService.CreateSubnet))
|
||||
require.NoError(t, err)
|
||||
defer createSubnetSub.Unsubscribe()
|
||||
|
||||
@@ -2607,21 +2601,21 @@ func TestDelegateHandlers_EIGW(t *testing.T) {
|
||||
{
|
||||
name: "CreateEgressOnlyInternetGateway",
|
||||
topic: "ec2.test.CreateEgressOnlyIGW",
|
||||
handler: daemon.handleEC2CreateEgressOnlyInternetGateway,
|
||||
handler: handleNATSRequest(daemon.eigwService.CreateEgressOnlyInternetGateway),
|
||||
input: &ec2.CreateEgressOnlyInternetGatewayInput{VpcId: aws.String("vpc-123")},
|
||||
expectedCode: awserrors.ErrorInvalidVpcIDNotFound,
|
||||
},
|
||||
{
|
||||
name: "DeleteEgressOnlyInternetGateway",
|
||||
topic: "ec2.test.DeleteEgressOnlyIGW",
|
||||
handler: daemon.handleEC2DeleteEgressOnlyInternetGateway,
|
||||
handler: handleNATSRequest(daemon.eigwService.DeleteEgressOnlyInternetGateway),
|
||||
input: &ec2.DeleteEgressOnlyInternetGatewayInput{EgressOnlyInternetGatewayId: aws.String("eigw-nonexistent")},
|
||||
expectedCode: awserrors.ErrorInvalidEgressOnlyInternetGatewayIdNotFound,
|
||||
},
|
||||
{
|
||||
name: "DescribeEgressOnlyInternetGateways",
|
||||
topic: "ec2.test.DescribeEgressOnlyIGWs",
|
||||
handler: daemon.handleEC2DescribeEgressOnlyInternetGateways,
|
||||
handler: handleNATSRequest(daemon.eigwService.DescribeEgressOnlyInternetGateways),
|
||||
input: &ec2.DescribeEgressOnlyInternetGatewaysInput{},
|
||||
},
|
||||
}
|
||||
@@ -2704,7 +2698,7 @@ func TestHandleEC2ModifyVolume_Success(t *testing.T) {
|
||||
func TestHandleEC2DescribeInstanceTypes_CapacityFilter(t *testing.T) {
|
||||
daemon := createFullTestDaemon(t, sharedNATSURL)
|
||||
|
||||
sub, err := daemon.natsConn.QueueSubscribe("ec2.DescribeInstanceTypes", "spinifex-workers", daemon.handleEC2DescribeInstanceTypes)
|
||||
sub, err := daemon.natsConn.QueueSubscribe("ec2.DescribeInstanceTypes", "spinifex-workers", handleNATSRequest(daemon.instanceService.DescribeInstanceTypes))
|
||||
require.NoError(t, err)
|
||||
defer sub.Unsubscribe()
|
||||
|
||||
@@ -2731,7 +2725,7 @@ func TestHandleEC2DescribeInstanceTypes_CapacityFilter(t *testing.T) {
|
||||
func TestHandleEC2DescribeInstanceTypes_NoFilter(t *testing.T) {
|
||||
daemon := createFullTestDaemon(t, sharedNATSURL)
|
||||
|
||||
sub, err := daemon.natsConn.QueueSubscribe("ec2.DescribeInstanceTypes.nofilter", "spinifex-workers", daemon.handleEC2DescribeInstanceTypes)
|
||||
sub, err := daemon.natsConn.QueueSubscribe("ec2.DescribeInstanceTypes.nofilter", "spinifex-workers", handleNATSRequest(daemon.instanceService.DescribeInstanceTypes))
|
||||
require.NoError(t, err)
|
||||
defer sub.Unsubscribe()
|
||||
|
||||
@@ -3353,7 +3347,7 @@ func TestHandleEC2DescribeInstanceStatus_RoundTrip(t *testing.T) {
|
||||
daemon.vmMgr.Insert(runningVM)
|
||||
t.Cleanup(func() { daemon.vmMgr.Delete(runningVM.ID) })
|
||||
|
||||
sub, err := daemon.natsConn.Subscribe("ec2.DescribeInstanceStatus.rt", daemon.handleEC2DescribeInstanceStatus)
|
||||
sub, err := daemon.natsConn.Subscribe("ec2.DescribeInstanceStatus.rt", handleNATSRequest(daemon.instanceService.DescribeInstanceStatus))
|
||||
require.NoError(t, err)
|
||||
defer sub.Unsubscribe()
|
||||
|
||||
@@ -3379,7 +3373,7 @@ func TestHandleEC2DescribeInstanceStatus_RoundTrip(t *testing.T) {
|
||||
func TestHandleEC2DescribeInstanceStatus_MalformedInstanceID(t *testing.T) {
|
||||
daemon := createFullTestDaemon(t, sharedNATSURL)
|
||||
|
||||
sub, err := daemon.natsConn.Subscribe("ec2.DescribeInstanceStatus.malformed", daemon.handleEC2DescribeInstanceStatus)
|
||||
sub, err := daemon.natsConn.Subscribe("ec2.DescribeInstanceStatus.malformed", handleNATSRequest(daemon.instanceService.DescribeInstanceStatus))
|
||||
require.NoError(t, err)
|
||||
defer sub.Unsubscribe()
|
||||
|
||||
@@ -3499,7 +3493,7 @@ func TestHandleEC2TerminateStoppedInstance_WritesToTerminatedKV(t *testing.T) {
|
||||
}
|
||||
require.NoError(t, daemon.jsManager.WriteStoppedInstance(stoppedVM.ID, stoppedVM))
|
||||
|
||||
sub, err := daemon.natsConn.QueueSubscribe("ec2.terminate", "spinifex-workers", daemon.handleEC2TerminateStoppedInstance)
|
||||
sub, err := daemon.natsConn.QueueSubscribe("ec2.terminate", "spinifex-workers", handleNATSRequest(daemon.instanceService.TerminateStoppedInstance))
|
||||
require.NoError(t, err)
|
||||
defer sub.Unsubscribe()
|
||||
|
||||
@@ -3566,34 +3560,34 @@ func TestDelegateHandlers_EIP(t *testing.T) {
|
||||
{
|
||||
name: "AllocateAddress",
|
||||
topic: "ec2.test.AllocateAddress",
|
||||
handler: daemon.handleEC2AllocateAddress,
|
||||
handler: handleNATSRequest(daemon.eipService.AllocateAddress),
|
||||
input: &ec2.AllocateAddressInput{},
|
||||
},
|
||||
{
|
||||
name: "ReleaseAddress",
|
||||
topic: "ec2.test.ReleaseAddress",
|
||||
handler: daemon.handleEC2ReleaseAddress,
|
||||
handler: handleNATSRequest(daemon.eipService.ReleaseAddress),
|
||||
input: &ec2.ReleaseAddressInput{AllocationId: aws.String("eipalloc-nonexistent")},
|
||||
expectedCode: awserrors.ErrorInvalidAllocationIDNotFound,
|
||||
},
|
||||
{
|
||||
name: "AssociateAddress",
|
||||
topic: "ec2.test.AssociateAddress",
|
||||
handler: daemon.handleEC2AssociateAddress,
|
||||
handler: handleNATSRequest(daemon.eipService.AssociateAddress),
|
||||
input: &ec2.AssociateAddressInput{AllocationId: aws.String("eipalloc-nonexistent")},
|
||||
expectedCode: awserrors.ErrorInvalidAllocationIDNotFound,
|
||||
},
|
||||
{
|
||||
name: "DisassociateAddress",
|
||||
topic: "ec2.test.DisassociateAddress",
|
||||
handler: daemon.handleEC2DisassociateAddress,
|
||||
handler: handleNATSRequest(daemon.eipService.DisassociateAddress),
|
||||
input: &ec2.DisassociateAddressInput{AssociationId: aws.String("eipassoc-nonexistent")},
|
||||
expectedCode: awserrors.ErrorInvalidAssociationIDNotFound,
|
||||
},
|
||||
{
|
||||
name: "DescribeAddresses",
|
||||
topic: "ec2.test.DescribeAddresses",
|
||||
handler: daemon.handleEC2DescribeAddresses,
|
||||
handler: handleNATSRequest(daemon.eipService.DescribeAddresses),
|
||||
input: &ec2.DescribeAddressesInput{},
|
||||
},
|
||||
}
|
||||
@@ -3622,7 +3616,7 @@ func TestDelegateHandlers_SecurityGroup(t *testing.T) {
|
||||
daemon := createVPCTestDaemon(t)
|
||||
|
||||
// Create a VPC first so SG operations have a valid target
|
||||
createVpcSub, err := daemon.natsConn.QueueSubscribe("ec2.CreateVpc", "spinifex-workers", daemon.handleEC2CreateVpc)
|
||||
createVpcSub, err := daemon.natsConn.QueueSubscribe("ec2.CreateVpc", "spinifex-workers", handleNATSRequest(daemon.vpcService.CreateVpc))
|
||||
require.NoError(t, err)
|
||||
defer createVpcSub.Unsubscribe()
|
||||
|
||||
@@ -3646,7 +3640,7 @@ func TestDelegateHandlers_SecurityGroup(t *testing.T) {
|
||||
{
|
||||
name: "CreateSecurityGroup",
|
||||
topic: "ec2.test.CreateSecurityGroup",
|
||||
handler: daemon.handleEC2CreateSecurityGroup,
|
||||
handler: handleNATSRequest(daemon.vpcService.CreateSecurityGroup),
|
||||
input: &ec2.CreateSecurityGroupInput{
|
||||
GroupName: aws.String("test-sg"),
|
||||
Description: aws.String("test security group"),
|
||||
@@ -3656,41 +3650,41 @@ func TestDelegateHandlers_SecurityGroup(t *testing.T) {
|
||||
{
|
||||
name: "DescribeSecurityGroups",
|
||||
topic: "ec2.test.DescribeSecurityGroups",
|
||||
handler: daemon.handleEC2DescribeSecurityGroups,
|
||||
handler: handleNATSRequest(daemon.vpcService.DescribeSecurityGroups),
|
||||
input: &ec2.DescribeSecurityGroupsInput{},
|
||||
},
|
||||
{
|
||||
name: "AuthorizeSecurityGroupIngress",
|
||||
topic: "ec2.test.AuthorizeSecurityGroupIngress",
|
||||
handler: daemon.handleEC2AuthorizeSecurityGroupIngress,
|
||||
handler: handleNATSRequest(daemon.vpcService.AuthorizeSecurityGroupIngress),
|
||||
input: &ec2.AuthorizeSecurityGroupIngressInput{GroupId: aws.String("sg-nonexistent")},
|
||||
expectedCode: awserrors.ErrorInvalidGroupNotFound,
|
||||
},
|
||||
{
|
||||
name: "AuthorizeSecurityGroupEgress",
|
||||
topic: "ec2.test.AuthorizeSecurityGroupEgress",
|
||||
handler: daemon.handleEC2AuthorizeSecurityGroupEgress,
|
||||
handler: handleNATSRequest(daemon.vpcService.AuthorizeSecurityGroupEgress),
|
||||
input: &ec2.AuthorizeSecurityGroupEgressInput{GroupId: aws.String("sg-nonexistent")},
|
||||
expectedCode: awserrors.ErrorInvalidGroupNotFound,
|
||||
},
|
||||
{
|
||||
name: "RevokeSecurityGroupIngress",
|
||||
topic: "ec2.test.RevokeSecurityGroupIngress",
|
||||
handler: daemon.handleEC2RevokeSecurityGroupIngress,
|
||||
handler: handleNATSRequest(daemon.vpcService.RevokeSecurityGroupIngress),
|
||||
input: &ec2.RevokeSecurityGroupIngressInput{GroupId: aws.String("sg-nonexistent")},
|
||||
expectedCode: awserrors.ErrorInvalidGroupNotFound,
|
||||
},
|
||||
{
|
||||
name: "RevokeSecurityGroupEgress",
|
||||
topic: "ec2.test.RevokeSecurityGroupEgress",
|
||||
handler: daemon.handleEC2RevokeSecurityGroupEgress,
|
||||
handler: handleNATSRequest(daemon.vpcService.RevokeSecurityGroupEgress),
|
||||
input: &ec2.RevokeSecurityGroupEgressInput{GroupId: aws.String("sg-nonexistent")},
|
||||
expectedCode: awserrors.ErrorInvalidGroupNotFound,
|
||||
},
|
||||
{
|
||||
name: "DeleteSecurityGroup",
|
||||
topic: "ec2.test.DeleteSecurityGroup",
|
||||
handler: daemon.handleEC2DeleteSecurityGroup,
|
||||
handler: handleNATSRequest(daemon.vpcService.DeleteSecurityGroup),
|
||||
input: &ec2.DeleteSecurityGroupInput{GroupId: aws.String("sg-nonexistent")},
|
||||
expectedCode: awserrors.ErrorInvalidGroupNotFound,
|
||||
},
|
||||
@@ -3752,27 +3746,27 @@ func TestDelegateHandlers_RouteTable(t *testing.T) {
|
||||
{
|
||||
name: "CreateRouteTable",
|
||||
topic: "ec2.test.CreateRouteTable",
|
||||
handler: daemon.handleEC2CreateRouteTable,
|
||||
handler: handleNATSRequest(daemon.routeTableService.CreateRouteTable),
|
||||
input: &ec2.CreateRouteTableInput{VpcId: aws.String("vpc-nonexistent")},
|
||||
expectedCode: awserrors.ErrorInvalidVpcIDNotFound,
|
||||
},
|
||||
{
|
||||
name: "DeleteRouteTable",
|
||||
topic: "ec2.test.DeleteRouteTable",
|
||||
handler: daemon.handleEC2DeleteRouteTable,
|
||||
handler: handleNATSRequest(daemon.routeTableService.DeleteRouteTable),
|
||||
input: &ec2.DeleteRouteTableInput{RouteTableId: aws.String("rtb-nonexistent")},
|
||||
expectedCode: awserrors.ErrorInvalidRouteTableIDNotFound,
|
||||
},
|
||||
{
|
||||
name: "DescribeRouteTables",
|
||||
topic: "ec2.test.DescribeRouteTables",
|
||||
handler: daemon.handleEC2DescribeRouteTables,
|
||||
handler: handleNATSRequest(daemon.routeTableService.DescribeRouteTables),
|
||||
input: &ec2.DescribeRouteTablesInput{},
|
||||
},
|
||||
{
|
||||
name: "CreateRoute",
|
||||
topic: "ec2.test.CreateRoute",
|
||||
handler: daemon.handleEC2CreateRoute,
|
||||
handler: handleNATSRequest(daemon.routeTableService.CreateRoute),
|
||||
input: &ec2.CreateRouteInput{
|
||||
RouteTableId: aws.String("rtb-nonexistent"),
|
||||
DestinationCidrBlock: aws.String("0.0.0.0/0"),
|
||||
@@ -3783,7 +3777,7 @@ func TestDelegateHandlers_RouteTable(t *testing.T) {
|
||||
{
|
||||
name: "DeleteRoute",
|
||||
topic: "ec2.test.DeleteRoute",
|
||||
handler: daemon.handleEC2DeleteRoute,
|
||||
handler: handleNATSRequest(daemon.routeTableService.DeleteRoute),
|
||||
input: &ec2.DeleteRouteInput{
|
||||
RouteTableId: aws.String("rtb-nonexistent"),
|
||||
DestinationCidrBlock: aws.String("0.0.0.0/0"),
|
||||
@@ -3793,7 +3787,7 @@ func TestDelegateHandlers_RouteTable(t *testing.T) {
|
||||
{
|
||||
name: "ReplaceRoute",
|
||||
topic: "ec2.test.ReplaceRoute",
|
||||
handler: daemon.handleEC2ReplaceRoute,
|
||||
handler: handleNATSRequest(daemon.routeTableService.ReplaceRoute),
|
||||
input: &ec2.ReplaceRouteInput{
|
||||
RouteTableId: aws.String("rtb-nonexistent"),
|
||||
DestinationCidrBlock: aws.String("0.0.0.0/0"),
|
||||
@@ -3804,7 +3798,7 @@ func TestDelegateHandlers_RouteTable(t *testing.T) {
|
||||
{
|
||||
name: "AssociateRouteTable",
|
||||
topic: "ec2.test.AssociateRouteTable",
|
||||
handler: daemon.handleEC2AssociateRouteTable,
|
||||
handler: handleNATSRequest(daemon.routeTableService.AssociateRouteTable),
|
||||
input: &ec2.AssociateRouteTableInput{
|
||||
RouteTableId: aws.String("rtb-nonexistent"),
|
||||
SubnetId: aws.String("subnet-nonexistent"),
|
||||
@@ -3814,14 +3808,14 @@ func TestDelegateHandlers_RouteTable(t *testing.T) {
|
||||
{
|
||||
name: "DisassociateRouteTable",
|
||||
topic: "ec2.test.DisassociateRouteTable",
|
||||
handler: daemon.handleEC2DisassociateRouteTable,
|
||||
handler: handleNATSRequest(daemon.routeTableService.DisassociateRouteTable),
|
||||
input: &ec2.DisassociateRouteTableInput{AssociationId: aws.String("rtbassoc-nonexistent")},
|
||||
expectedCode: awserrors.ErrorInvalidAssociationIDNotFound,
|
||||
},
|
||||
{
|
||||
name: "ReplaceRouteTableAssociation",
|
||||
topic: "ec2.test.ReplaceRouteTableAssociation",
|
||||
handler: daemon.handleEC2ReplaceRouteTableAssociation,
|
||||
handler: handleNATSRequest(daemon.routeTableService.ReplaceRouteTableAssociation),
|
||||
input: &ec2.ReplaceRouteTableAssociationInput{
|
||||
AssociationId: aws.String("rtbassoc-nonexistent"),
|
||||
RouteTableId: aws.String("rtb-nonexistent"),
|
||||
@@ -3885,7 +3879,7 @@ func TestDelegateHandlers_PlacementGroup(t *testing.T) {
|
||||
{
|
||||
name: "CreatePlacementGroup",
|
||||
topic: "ec2.test.CreatePlacementGroup",
|
||||
handler: daemon.handleEC2CreatePlacementGroup,
|
||||
handler: handleNATSRequest(daemon.placementGroupService.CreatePlacementGroup),
|
||||
input: &ec2.CreatePlacementGroupInput{
|
||||
GroupName: aws.String("test-pg"),
|
||||
Strategy: aws.String("spread"),
|
||||
@@ -3894,20 +3888,20 @@ func TestDelegateHandlers_PlacementGroup(t *testing.T) {
|
||||
{
|
||||
name: "DescribePlacementGroups",
|
||||
topic: "ec2.test.DescribePlacementGroups",
|
||||
handler: daemon.handleEC2DescribePlacementGroups,
|
||||
handler: handleNATSRequest(daemon.placementGroupService.DescribePlacementGroups),
|
||||
input: &ec2.DescribePlacementGroupsInput{},
|
||||
},
|
||||
{
|
||||
name: "DeletePlacementGroup",
|
||||
topic: "ec2.test.DeletePlacementGroup",
|
||||
handler: daemon.handleEC2DeletePlacementGroup,
|
||||
handler: handleNATSRequest(daemon.placementGroupService.DeletePlacementGroup),
|
||||
input: &ec2.DeletePlacementGroupInput{GroupName: aws.String("pg-nonexistent")},
|
||||
expectedCode: awserrors.ErrorInvalidPlacementGroupUnknown,
|
||||
},
|
||||
{
|
||||
name: "ReserveSpreadNodes",
|
||||
topic: "ec2.test.ReserveSpreadNodes",
|
||||
handler: daemon.handleEC2ReserveSpreadNodes,
|
||||
handler: handleNATSRequest(daemon.placementGroupService.ReserveSpreadNodes),
|
||||
input: &handlers_ec2_placementgroup.ReserveSpreadNodesInput{
|
||||
GroupName: "pg-nonexistent",
|
||||
EligibleNodes: []string{"node-1"},
|
||||
@@ -3919,7 +3913,7 @@ func TestDelegateHandlers_PlacementGroup(t *testing.T) {
|
||||
{
|
||||
name: "FinalizeSpreadInstances",
|
||||
topic: "ec2.test.FinalizeSpreadInstances",
|
||||
handler: daemon.handleEC2FinalizeSpreadInstances,
|
||||
handler: handleNATSRequest(daemon.placementGroupService.FinalizeSpreadInstances),
|
||||
input: &handlers_ec2_placementgroup.FinalizeSpreadInstancesInput{
|
||||
GroupName: "pg-nonexistent",
|
||||
NodeInstances: map[string][]string{"node-1": {"i-123"}},
|
||||
@@ -3929,7 +3923,7 @@ func TestDelegateHandlers_PlacementGroup(t *testing.T) {
|
||||
{
|
||||
name: "ReleaseSpreadNodes",
|
||||
topic: "ec2.test.ReleaseSpreadNodes",
|
||||
handler: daemon.handleEC2ReleaseSpreadNodes,
|
||||
handler: handleNATSRequest(daemon.placementGroupService.ReleaseSpreadNodes),
|
||||
input: &handlers_ec2_placementgroup.ReleaseSpreadNodesInput{
|
||||
GroupName: "pg-nonexistent",
|
||||
Nodes: []string{"node-1"},
|
||||
@@ -3939,7 +3933,7 @@ func TestDelegateHandlers_PlacementGroup(t *testing.T) {
|
||||
{
|
||||
name: "RemoveInstanceFromPlacementGroup",
|
||||
topic: "ec2.test.RemoveInstanceFromPlacementGroup",
|
||||
handler: daemon.handleEC2RemoveInstanceFromPlacementGroup,
|
||||
handler: handleNATSRequest(daemon.placementGroupService.RemoveInstance),
|
||||
input: &handlers_ec2_placementgroup.RemoveInstanceInput{
|
||||
GroupName: "pg-nonexistent",
|
||||
NodeName: "node-1",
|
||||
@@ -3952,7 +3946,7 @@ func TestDelegateHandlers_PlacementGroup(t *testing.T) {
|
||||
{
|
||||
name: "ReserveClusterNode",
|
||||
topic: "ec2.test.ReserveClusterNode",
|
||||
handler: daemon.handleEC2ReserveClusterNode,
|
||||
handler: handleNATSRequest(daemon.placementGroupService.ReserveClusterNode),
|
||||
input: &handlers_ec2_placementgroup.ReserveClusterNodeInput{
|
||||
GroupName: "pg-nonexistent",
|
||||
EligibleNodes: []string{"node-1"},
|
||||
@@ -3962,7 +3956,7 @@ func TestDelegateHandlers_PlacementGroup(t *testing.T) {
|
||||
{
|
||||
name: "FinalizeClusterInstances",
|
||||
topic: "ec2.test.FinalizeClusterInstances",
|
||||
handler: daemon.handleEC2FinalizeClusterInstances,
|
||||
handler: handleNATSRequest(daemon.placementGroupService.FinalizeClusterInstances),
|
||||
input: &handlers_ec2_placementgroup.FinalizeClusterInstancesInput{
|
||||
GroupName: "pg-nonexistent",
|
||||
NodeInstances: map[string][]string{"node-1": {"i-123"}},
|
||||
@@ -3995,7 +3989,7 @@ func TestDelegateHandlers_VPCAttributes(t *testing.T) {
|
||||
daemon := createVPCTestDaemon(t)
|
||||
|
||||
// Create a VPC first
|
||||
createVpcSub, err := daemon.natsConn.QueueSubscribe("ec2.CreateVpc", "spinifex-workers", daemon.handleEC2CreateVpc)
|
||||
createVpcSub, err := daemon.natsConn.QueueSubscribe("ec2.CreateVpc", "spinifex-workers", handleNATSRequest(daemon.vpcService.CreateVpc))
|
||||
require.NoError(t, err)
|
||||
defer createVpcSub.Unsubscribe()
|
||||
|
||||
@@ -4019,7 +4013,7 @@ func TestDelegateHandlers_VPCAttributes(t *testing.T) {
|
||||
{
|
||||
name: "ModifySubnetAttribute",
|
||||
topic: "ec2.test.ModifySubnetAttribute",
|
||||
handler: daemon.handleEC2ModifySubnetAttribute,
|
||||
handler: handleNATSRequest(daemon.vpcService.ModifySubnetAttribute),
|
||||
input: &ec2.ModifySubnetAttributeInput{SubnetId: aws.String("subnet-nonexistent")},
|
||||
expectedCode: awserrors.ErrorInvalidSubnetIDNotFound,
|
||||
},
|
||||
@@ -4029,14 +4023,14 @@ func TestDelegateHandlers_VPCAttributes(t *testing.T) {
|
||||
// the validation contract.
|
||||
name: "ModifyVpcAttribute",
|
||||
topic: "ec2.test.ModifyVpcAttribute",
|
||||
handler: daemon.handleEC2ModifyVpcAttribute,
|
||||
handler: handleNATSRequest(daemon.vpcService.ModifyVpcAttribute),
|
||||
input: &ec2.ModifyVpcAttributeInput{VpcId: aws.String(vpcID)},
|
||||
expectedCode: awserrors.ErrorInvalidParameterValue,
|
||||
},
|
||||
{
|
||||
name: "DescribeVpcAttribute",
|
||||
topic: "ec2.test.DescribeVpcAttribute",
|
||||
handler: daemon.handleEC2DescribeVpcAttribute,
|
||||
handler: handleNATSRequest(daemon.vpcService.DescribeVpcAttribute),
|
||||
input: &ec2.DescribeVpcAttributeInput{
|
||||
VpcId: aws.String(vpcID),
|
||||
Attribute: aws.String("enableDnsSupport"),
|
||||
@@ -4047,7 +4041,7 @@ func TestDelegateHandlers_VPCAttributes(t *testing.T) {
|
||||
// "exactly one attribute" guard before the ENI lookup runs.
|
||||
name: "ModifyNetworkInterfaceAttribute",
|
||||
topic: "ec2.test.ModifyNetworkInterfaceAttribute",
|
||||
handler: daemon.handleEC2ModifyNetworkInterfaceAttribute,
|
||||
handler: handleNATSRequest(daemon.vpcService.ModifyNetworkInterfaceAttribute),
|
||||
input: &ec2.ModifyNetworkInterfaceAttributeInput{NetworkInterfaceId: aws.String("eni-nonexistent")},
|
||||
expectedCode: awserrors.ErrorInvalidParameterValue,
|
||||
},
|
||||
|
||||
@@ -160,22 +160,6 @@ func attachDetachErrorCode(err error) string {
|
||||
}
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2CreateVolume(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.volumeService.CreateVolume)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DescribeVolumes(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.volumeService.DescribeVolumes)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DescribeVolumeStatus(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.volumeService.DescribeVolumeStatus)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DescribeVolumesModifications(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.volumeService.DescribeVolumesModifications)
|
||||
}
|
||||
|
||||
// handleEC2ModifyVolume processes incoming EC2 ModifyVolume requests.
|
||||
func (d *Daemon) handleEC2ModifyVolume(msg *nats.Msg) {
|
||||
ctx, span := utils.StartConsumerSpan(msg)
|
||||
@@ -227,7 +211,3 @@ func (d *Daemon) handleEC2ModifyVolume(msg *nats.Msg) {
|
||||
|
||||
slog.InfoContext(ctx, "handleEC2ModifyVolume completed", "volumeId", modifyVolumeInput.VolumeId)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DeleteVolume(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.volumeService.DeleteVolume)
|
||||
}
|
||||
|
||||
@@ -12,58 +12,6 @@ import (
|
||||
"github.com/nats-io/nats.go"
|
||||
)
|
||||
|
||||
func (d *Daemon) handleEC2CreateVpc(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.vpcService.CreateVpc)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DeleteVpc(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.vpcService.DeleteVpc)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DescribeVpcs(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.vpcService.DescribeVpcs)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2CreateSubnet(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.vpcService.CreateSubnet)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DeleteSubnet(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.vpcService.DeleteSubnet)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DescribeSubnets(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.vpcService.DescribeSubnets)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2ModifySubnetAttribute(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.vpcService.ModifySubnetAttribute)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2ModifyVpcAttribute(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.vpcService.ModifyVpcAttribute)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DescribeVpcAttribute(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.vpcService.DescribeVpcAttribute)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2CreateNetworkInterface(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.vpcService.CreateNetworkInterface)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DeleteNetworkInterface(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.vpcService.DeleteNetworkInterface)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2ModifyNetworkInterfaceAttribute(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.vpcService.ModifyNetworkInterfaceAttribute)
|
||||
}
|
||||
|
||||
func (d *Daemon) handleEC2DescribeNetworkInterfaces(msg *nats.Msg) {
|
||||
handleNATSRequest(msg, d.vpcService.DescribeNetworkInterfaces)
|
||||
}
|
||||
|
||||
// handleAccountCreated creates a default VPC for a newly created account.
|
||||
func (d *Daemon) handleAccountCreated(msg *nats.Msg) {
|
||||
ctx, span := utils.StartConsumerSpan(msg)
|
||||
|
||||
@@ -384,7 +384,7 @@ func TestHandleEC2DescribeInstanceTypes(t *testing.T) {
|
||||
daemon := createTestDaemon(t, natsURL)
|
||||
|
||||
// Subscribe to DescribeInstanceTypes (no queue group for fan-out)
|
||||
sub, err := daemon.natsConn.Subscribe("ec2.DescribeInstanceTypes", daemon.handleEC2DescribeInstanceTypes)
|
||||
sub, err := daemon.natsConn.Subscribe("ec2.DescribeInstanceTypes", handleNATSRequest(daemon.instanceService.DescribeInstanceTypes))
|
||||
require.NoError(t, err, "Failed to subscribe to ec2.DescribeInstanceTypes")
|
||||
defer sub.Unsubscribe()
|
||||
|
||||
|
||||
@@ -5,6 +5,7 @@ import (
|
||||
"testing"
|
||||
|
||||
"github.com/mulgadc/spinifex/spinifex/config"
|
||||
handlers_ec2_eip "github.com/mulgadc/spinifex/spinifex/handlers/ec2/eip"
|
||||
handlers_elbv2 "github.com/mulgadc/spinifex/spinifex/handlers/elbv2"
|
||||
"github.com/mulgadc/spinifex/spinifex/testutil"
|
||||
"github.com/nats-io/nats.go"
|
||||
@@ -261,6 +262,10 @@ func newSubscribeTestDaemon(t *testing.T, nc *nats.Conn, gatewayURL, accessKey s
|
||||
natsSubscriptions: make(map[string]*nats.Subscription),
|
||||
elbv2Service: svc,
|
||||
systemAccessKey: accessKey,
|
||||
// subscribeAll now binds d.eipService.Method eagerly; production always
|
||||
// sets the disabled stub when EIP is unconfigured, so mirror that here to
|
||||
// avoid a nil-interface method-value panic while building the table.
|
||||
eipService: handlers_ec2_eip.NewDisabledEIPService(),
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user