public async Task <NetworkInterfaceInfo> GetAsync(string name)
{
Ensure.NotNullOrEmpty(name, nameof(name));
if (long.TryParse(name, out var id))
{
return(await GetAsync(id));
}
var(provider, resourceId) = ResourceName.Parse(name);
return(await FindAsync(provider, resourceId)
?? throw ResourceError.NotFound(ManagedResource.NetworkInterface(provider, name)));
}
public async Task <NetworkInterfaceInfo> GetAsync(ResourceProvider provider, string resourceId)
{
var record = await networkInterfaces.FindAsync(provider, resourceId);;
if (record == null)
{
var nic = await ec2.DescribeNetworkInterfaceAsync(resourceId)
?? throw ResourceError.NotFound(Aws, ResourceTypes.NetworkInterface, resourceId);
var network = await networkService.GetAsync(Aws, nic.VpcId);
var region = Locations.Get(network.LocationId);
SubnetInfo subnet = nic.SubnetId != null
? await subnetService.FindAsync(Aws, nic.SubnetId)
: null;
var securityGroupIds = new long[nic.Groups.Length];
for (var i = 0; i < securityGroupIds.Length; i++)
{
var nsg = await nsgManager.GetAsync(network, nic.Groups[i]);;
securityGroupIds[i] = nsg.Id;
}
// TODO: Lookup host & create an attachment (ni.Attachment?.AttachTime) ...
var registerRequest = new RegisterNetworkInterfaceRequest(
mac: MacAddress.Parse(nic.MacAddress),
subnetId: subnet?.Id ?? 0,
securityGroupIds: securityGroupIds,
resource: ManagedResource.NetworkInterface(region, nic.NetworkInterfaceId)
);
record = await networkInterfaces.RegisterAsync(registerRequest);;
}
return(record);
}
private async Task <RegisterHostRequest> GetRegistrationAsync(
Instance instance,
Cluster cluster,
IImage image = null,
ILocation location = null,
IMachineType machineType = null)
{
Validate.NotNull(instance, nameof(instance));
// Ensure the instance is inside a VPC (no classic instances)
if (instance.VpcId == null)
{
throw new ArgumentException("Must belong to a VPC", nameof(instance));
}
#region Data Binding / Mappings
if (location == null)
{
location = Locations.Get(aws, instance.Placement.AvailabilityZone);
}
if (image == null)
{
// "imageId": "ami-1647537c",
image = await imageService.GetAsync(aws, instance.ImageId);;
}
if (machineType == null)
{
machineType = AwsInstanceType.Get(instance.InstanceType);
}
var network = await db.Networks.FindAsync(aws, instance.VpcId);;
#endregion
// instance.LaunchTime
int addressCount = 1;
if (instance.IpAddress != null)
{
addressCount++;
}
var addresses = new string[addressCount];
addresses[0] = instance.PrivateIpAddress;
if (instance.IpAddress != null)
{
// the instance was assigned a public IP
addresses[1] = instance.IpAddress;
}
var registerRequest = new RegisterHostRequest(
addresses: addresses,
cluster: cluster,
image: image,
machineType: machineType,
program: null,
location: location,
status: instance.InstanceState.ToStatus(),
ownerId: 1,
resource: ManagedResource.Host(location, instance.InstanceId)
);
#region Network Interfaces
try
{
var nics = new RegisterNetworkInterfaceRequest[instance.NetworkInterfaces.Length];
for (var nicIndex = 0; nicIndex < nics.Length; nicIndex++)
{
var ec2Nic = instance.NetworkInterfaces[nicIndex];
nics[nicIndex] = new RegisterNetworkInterfaceRequest(
mac: MacAddress.Parse(ec2Nic.MacAddress),
subnetId: 0, // TODO: lookup subnet
securityGroupIds: Array.Empty <long>(), // TODO: lookup security groupds
resource: ManagedResource.NetworkInterface(location, ec2Nic.NetworkInterfaceId)
);
}
registerRequest.NetworkInterfaces = nics;
}
catch { }
#endregion
#region Volumes
try
{
var volumes = new RegisterVolumeRequest[instance.BlockDeviceMappings.Length];
for (var volumeIndex = 0; volumeIndex < volumes.Length; volumeIndex++)
{
var device = instance.BlockDeviceMappings[volumeIndex];
if (device.Ebs == null)
{
continue;
}
var volumeSize = device.Ebs.VolumeSize is int ebsSize
? ByteSize.FromGiB(ebsSize)
: ByteSize.Zero;
volumes[volumeIndex] = new RegisterVolumeRequest(
ownerId: 1,
size: volumeSize,
resource: ManagedResource.Volume(location, device.Ebs.VolumeId)
);
}
registerRequest.Volumes = volumes;
}
catch { }
#endregion
return(registerRequest);
}
