public async Task <Subnet> DescribeSubnets(string vpcId)
{
List <Filter> filters = new List <Filter>
{
new Filter
{
Name = "vpc-id",
Values = new List <string>
{
vpcId
}
}
};
DescribeSubnetsRequest request = new DescribeSubnetsRequest {
Filters = filters
};
DescribeSubnetsResponse response = await _ec2Client.DescribeSubnetsAsync(request);
List <Subnet> subnets = new List <Subnet>();
foreach (var item in response.Subnets)
{
subnets.Add(new Subnet(item.SubnetId, item.VpcId, item.AvailabilityZoneId, item.AvailabilityZone, item.CidrBlock));
}
return(subnets.FirstOrDefault());
}
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override AmazonWebServiceResponse Unmarshall(XmlUnmarshallerContext context)
{
DescribeSubnetsResponse response = new DescribeSubnetsResponse();
int originalDepth = context.CurrentDepth;
int targetDepth = originalDepth + 1;
if (context.IsStartOfDocument)
{
targetDepth = 2;
}
while (context.ReadAtDepth(originalDepth))
{
if (context.IsStartElement || context.IsAttribute)
{
if (context.TestExpression("subnetSet/item", targetDepth))
{
var unmarshaller = SubnetUnmarshaller.Instance;
var item = unmarshaller.Unmarshall(context);
response.Subnets.Add(item);
continue;
}
}
}
return(response);
}
public override void Invoke(AWSCredentials creds, RegionEndpoint region, int maxItems)
{
AmazonEC2Config config = new AmazonEC2Config();
config.RegionEndpoint = region;
ConfigureClient(config);
AmazonEC2Client client = new AmazonEC2Client(creds, config);
DescribeSubnetsResponse resp = new DescribeSubnetsResponse();
do
{
DescribeSubnetsRequest req = new DescribeSubnetsRequest
{
NextToken = resp.NextToken
,
MaxResults = maxItems
};
resp = client.DescribeSubnets(req);
CheckError(resp.HttpStatusCode, "200");
foreach (var obj in resp.Subnets)
{
AddObject(obj);
}
}while (!string.IsNullOrEmpty(resp.NextToken));
}
public void GetSubnetsByVpcId_Ok()
{
// Arrange
const string vpcId = "VpcOne";
var subnetInVpcOne = new Subnet {
VpcId = vpcId
};
var subnetInVpcTwo = new Subnet {
VpcId = "VpcTwo"
};
var subnets = new List <Subnet>
{
subnetInVpcOne,
subnetInVpcTwo
};
var response = new DescribeSubnetsResponse {
Subnets = subnets
};
Ec2ClientMock.Setup(x => x.DescribeSubnets(It.IsAny <DescribeSubnetsRequest>())).Returns(response);
// Act
var actualSubnets = NetworkService.GetSubnets(vpcId);
// Assert
actualSubnets.Single().Should().BeSameAs(subnetInVpcOne);
}
public List <DescribeSubnetModel> MapForDescribe(DescribeSubnetsResponse describeSubnetsResponse)
{
var model = new List <DescribeSubnetModel>();
foreach (var subnet in describeSubnetsResponse.Subnets)
{
model.Add(new DescribeSubnetModel()
{
SubnetId = subnet.SubnetId
});
}
return(model);
}
public override void Invoke(AWSCredentials creds, RegionEndpoint region, int maxItems)
{
AmazonEC2Config config = new AmazonEC2Config();
config.RegionEndpoint = region;
ConfigureClient(config);
AmazonEC2Client client = new AmazonEC2Client(creds, config);
DescribeSubnetsResponse resp = new DescribeSubnetsResponse();
DescribeSubnetsRequest req = new DescribeSubnetsRequest
{
};
resp = client.DescribeSubnets(req);
CheckError(resp.HttpStatusCode, "200");
foreach (var obj in resp.Subnets)
{
AddObject(obj);
}
}
public void GetCidrBySubnet_Ok()
{
// Arrange
const string subnetId = "SubnetOne";
const string cidr = "192.0.0.0/24";
var response = new DescribeSubnetsResponse {
Subnets = new List <Subnet> {
new Subnet {
CidrBlock = "192.0.0.0/24"
}
}
};
Ec2ClientMock.Setup(x => x.DescribeSubnets(It.Is <DescribeSubnetsRequest>(req => req.SubnetIds.Contains("SubnetOne")))).Returns(response);
// Act
var results = NetworkService.GetCidrBySubnetId(subnetId);
// Assert
results.Should().Be(cidr);
}
public override AmazonWebServiceResponse Unmarshall(XmlUnmarshallerContext context)
{
DescribeSubnetsResponse response = new DescribeSubnetsResponse();
int targetDepth = 2;
while (context.Read())
{
if (context.IsStartElement || context.IsAttribute)
{
if (context.TestExpression("subnetSet/item", targetDepth))
{
response.Subnets.Add(SubnetUnmarshaller.GetInstance().Unmarshall(context));
continue;
}
}
}
return(response);
}
internal void LaunchServer(ref bool actionSucceeded, ref string actionMessage)
{
try
{
string keyPairPath = string.Empty;
LaunchRequest.KeyPairName = $"KeyPair-{Guid.NewGuid().ToString()}";
while (!CreateKeyPair(LaunchRequest.KeyPairName, ref keyPairPath))
{
LaunchRequest.KeyPairName = Guid.NewGuid().ToString();
}
DescribeVpcsRequest vpcRequest = new DescribeVpcsRequest();
DescribeVpcsResponse vpcResponse = Ec2Client.DescribeVpcsAsync(vpcRequest).GetAwaiter().GetResult();
Vpc defaultVPC = vpcResponse.Vpcs.Find(x => x.IsDefault); //get the default vpc
List <Filter> subnetFilter = new List <Filter>()
{
new Filter()
{
Name = "availability-zone", Values = new List <string>()
{
LaunchRequest.AvailabilityZone
}
},
new Filter()
{
Name = "vpc-id", Values = new List <string>()
{
defaultVPC.VpcId
}
}
};
DescribeSubnetsRequest subnetRequest = new DescribeSubnetsRequest();
subnetRequest.Filters = subnetFilter;
DescribeSubnetsResponse subnetResponse = Ec2Client.DescribeSubnetsAsync(subnetRequest).GetAwaiter().GetResult();
Subnet defaultSubnet = subnetResponse.Subnets.FirstOrDefault();
Filter SGFilter = new Filter
{
Name = "vpc-id",
Values = new List <string>()
{
defaultVPC.VpcId
}
};
DescribeSecurityGroupsRequest SGrequest = new DescribeSecurityGroupsRequest();
SGrequest.Filters.Add(SGFilter);
DescribeSecurityGroupsResponse SGresponse = Ec2Client.DescribeSecurityGroupsAsync(SGrequest).GetAwaiter().GetResult();
SecurityGroup defaultSG = SGresponse.SecurityGroups.FirstOrDefault();
InstanceNetworkInterfaceSpecification defaultENI = new InstanceNetworkInterfaceSpecification()
{
DeviceIndex = 0,
SubnetId = defaultSubnet.SubnetId,
Groups = new List <string>()
{
defaultSG.GroupId
},
AssociatePublicIpAddress = true
};
List <InstanceNetworkInterfaceSpecification> enis = new List <InstanceNetworkInterfaceSpecification>()
{
defaultENI
};
EbsBlockDevice ebsBlockDevice = new EbsBlockDevice
{
VolumeSize = 10,
VolumeType = GetActualStorageType(LaunchRequest.StorageType)
};
BlockDeviceMapping blockDeviceMapping = new BlockDeviceMapping
{
DeviceName = "/dev/xvda"
};
blockDeviceMapping.Ebs = ebsBlockDevice;
var launchRequest = new RunInstancesRequest()
{
ImageId = GetImageID(LaunchRequest.AMIType),
InstanceType = GetActualInstanceType(LaunchRequest.InstanceType),
MinCount = LaunchRequest.NumOfInstances,
MaxCount = LaunchRequest.NumOfInstances,
KeyName = LaunchRequest.KeyPairName,
Placement = new Placement(LaunchRequest.AvailabilityZone),
NetworkInterfaces = enis,
BlockDeviceMappings = new List <BlockDeviceMapping>()
{
blockDeviceMapping
}
};
RunInstancesResponse launchResponse = Ec2Client.RunInstancesAsync(launchRequest).GetAwaiter().GetResult();
List <String> instanceIds = new List <string>();
foreach (Instance instance in launchResponse.Reservation.Instances)
{
Console.WriteLine(instance.InstanceId);
instanceIds.Add(instance.InstanceId);
}
actionSucceeded = true;
actionMessage = $"The instance(s) are being launched. Please check the AWS Console to verify. {keyPairPath}";
}
catch (Exception ex)
{
context.Logger.LogLine($"ServerOperationsHelper::LaunchServer {ex.Message}");
context.Logger.LogLine($"ServerOperationsHelper::LaunchServer {ex.StackTrace}");
actionSucceeded = false;
actionMessage = $"Could not launch the server . Please contact your administrator.";
}
}
public virtual void failover()
{
try
{
// Modify the autoscaling group to remove the AZ affected which is the AZ passed in the input
// Find the autoscaling group that this is deployed into
// Note: This changes the asynchronous call to a synchronous one
DescribeAutoScalingGroupsResponse autoScalingGroupsResponse = AUTO_SCALING_CLIENT.DescribeAutoScalingGroupsAsync().GetAwaiter().GetResult();
if (autoScalingGroupsResponse != null && autoScalingGroupsResponse.AutoScalingGroups.Count > 0)
{
// Note: This assumes an Auto Scaling group exists; no error checking for readability
AutoScalingGroup autoScalingGroup = autoScalingGroupsResponse.AutoScalingGroups[0];
string autoScalingGroupName = autoScalingGroup.AutoScalingGroupName;
// Find all subnets in the availability zone passed in the input
DescribeSubnetsResponse subnetsResult
= EC2_CLIENT.DescribeSubnetsAsync(new DescribeSubnetsRequest()
{
Filters = new List <Amazon.EC2.Model.Filter> {
new Amazon.EC2.Model.Filter {
Name = "vpc-id",
Values = new List <string> {
vpcId
}
}
}
}).GetAwaiter().GetResult();
IList <string> desiredSubnetsForASG = new List <string>();
foreach (Amazon.EC2.Model.Subnet subnet in subnetsResult.Subnets)
{
if (!string.Equals(subnet.AvailabilityZone, azId, StringComparison.OrdinalIgnoreCase))
{
desiredSubnetsForASG.Add(subnet.SubnetId);
}
}
List <string> desiredSubnets = new List <String>(autoScalingGroup.VPCZoneIdentifier.Split(new[] { ',' }, StringSplitOptions.None));
var tempList = new List <String>(desiredSubnets);
foreach (var subnet in desiredSubnets)
{
if (!desiredSubnetsForASG.Contains(subnet))
{
tempList.Remove(subnet);
}
}
desiredSubnets = tempList;
Console.WriteLine("Updating the auto scaling group " + autoScalingGroupName + " to remove the subnet in the AZ");
// Note: This turns the asynchronous call into a synchronous one
UpdateAutoScalingGroupResponse updateAutoScalingGroupResponse
= AUTO_SCALING_CLIENT.UpdateAutoScalingGroupAsync(new UpdateAutoScalingGroupRequest
{
AutoScalingGroupName = autoScalingGroupName,
VPCZoneIdentifier = string.Join(",", desiredSubnets)
}).GetAwaiter().GetResult();
}
// Find all subnets in the availability zone passed in the input
// Note: This turns the asynchronous call into a synchronous one
DescribeSubnetsResponse describeSubnetsResult
= EC2_CLIENT.DescribeSubnetsAsync(new DescribeSubnetsRequest
{
Filters = new List <Amazon.EC2.Model.Filter> {
new Amazon.EC2.Model.Filter {
Name = "vpc-id",
Values = new List <string> {
vpcId
}
},
new Amazon.EC2.Model.Filter {
Name = "availabilityZone",
Values = new List <string> {
azId
}
}
}
}).GetAwaiter().GetResult();
IList <string> desiredSubnetsForAddingNewNacl = new List <string>();
foreach (Amazon.EC2.Model.Subnet subnet in describeSubnetsResult.Subnets)
{
desiredSubnetsForAddingNewNacl.Add(subnet.SubnetId);
}
//Find all the network acl associations matching the subnets identified above
// Note: This turns the asynchronous call into a synchronous one
DescribeNetworkAclsResponse describeNetworkAclsResult
= EC2_CLIENT.DescribeNetworkAclsAsync(new DescribeNetworkAclsRequest()
{
Filters = new List <Amazon.EC2.Model.Filter> {
new Amazon.EC2.Model.Filter {
Name = "association.subnet-id",
Values = (List <string>)desiredSubnetsForAddingNewNacl
}
}
}).GetAwaiter().GetResult();
IList <NetworkAclAssociation> desiredAclAssociations = new List <NetworkAclAssociation>();
// Note: This assumes a Network ACL is present for readability
IList <NetworkAclAssociation> networkAclsAssociatedWithSubnet = describeNetworkAclsResult.NetworkAcls[0].Associations;
foreach (string subnetId in desiredSubnetsForAddingNewNacl)
{
foreach (NetworkAclAssociation networkAcl in networkAclsAssociatedWithSubnet)
{
if (string.Equals(networkAcl.SubnetId, subnetId, StringComparison.OrdinalIgnoreCase))
{
desiredAclAssociations.Add(networkAcl);
}
}
}
//create new network acl association with both ingress and egress denying to all the traffic
CreateNetworkAclRequest createNetworkAclRequest = new CreateNetworkAclRequest();
createNetworkAclRequest.VpcId = vpcId;
// Note: This turns the asynchronous call into a synchronous one
CreateNetworkAclResponse createNetworkAclResponse = EC2_CLIENT.CreateNetworkAclAsync(createNetworkAclRequest).GetAwaiter().GetResult();
string networkAclId = createNetworkAclResponse.NetworkAcl.NetworkAclId;
createNetworkAclEntry(networkAclId, 100, "0.0.0.0/0", true, "-1", createPortRange(0, 65535), RuleAction.Deny);
createNetworkAclEntry(networkAclId, 101, "0.0.0.0/0", false, "-1", createPortRange(0, 65535), RuleAction.Deny);
// replace all the network acl associations identified for the above subnets with the new network
// acl association which will deny all traffic for those subnets in that AZ
Console.WriteLine("Creating new network ACL associations");
replaceNetworkAclAssociations(desiredAclAssociations, networkAclId);
//fail over rds which is in the same AZ
// Note: This turns the asynchronous call into a synchronous one
DescribeDBInstancesResponse describeDBInstancesResult = RDS_CLIENT.DescribeDBInstancesAsync().GetAwaiter().GetResult();
IList <DBInstance> dbInstances = describeDBInstancesResult.DBInstances;
string dbInstancedId = null;
foreach (DBInstance dbInstance in dbInstances)
{
if (string.Equals(dbInstance.DBSubnetGroup.VpcId, vpcId, StringComparison.OrdinalIgnoreCase) &&
(string.Equals(dbInstance.AvailabilityZone, azId, StringComparison.OrdinalIgnoreCase)) &&
dbInstance.MultiAZ && dbInstance.StatusInfos.Count == 0)
{
dbInstancedId = dbInstance.DBInstanceIdentifier;
}
}
// we want to fail over rds if rds is present in the same az where it is affected
if (!string.IsNullOrEmpty(dbInstancedId))
{
RebootDBInstanceRequest rebootDBInstanceRequest = new RebootDBInstanceRequest();
rebootDBInstanceRequest.DBInstanceIdentifier = dbInstancedId;
rebootDBInstanceRequest.ForceFailover = true;
Console.WriteLine("Rebooting dbInstanceId to secondary AZ " + dbInstancedId);
// Note: This turns the asynchronous call into a synchronous one
RDS_CLIENT.RebootDBInstanceAsync(rebootDBInstanceRequest).GetAwaiter().GetResult();
}
}
catch (Exception exception)
{
Console.WriteLine("Unkown exception occured " + exception.Message);
}
}
public virtual async Task Failover()
{
try
{
Console.WriteLine($"Simulating AZ failure for {azName}");
// Find all subnets in the availability zone passed in the input
DescribeSubnetsResponse subnetsInSpecifiedAZandVpc
= await ec2Client.DescribeSubnetsAsync(new DescribeSubnetsRequest()
{
Filters = new List <Amazon.EC2.Model.Filter> {
new Amazon.EC2.Model.Filter {
Name = "vpc-id",
Values = { vpcId }
},
new Amazon.EC2.Model.Filter {
Name = "availability-zone",
Values = { azName }
}
}
});
List <string> subnetIdsInSpecifiedAZ = subnetsInSpecifiedAZandVpc.Subnets.Select(x => x.SubnetId).ToList();
// Modify the autoscaling group to remove the AZ affected which is the AZ passed in the input
// Find the autoscaling group that this is deployed into
DescribeAutoScalingGroupsResponse autoScalingGroupsResponse = await asClient.DescribeAutoScalingGroupsAsync();
if (autoScalingGroupsResponse != null && autoScalingGroupsResponse.AutoScalingGroups.Count > 0)
{
// Note: This assumes an Auto Scaling group exists; no error checking for readability
AutoScalingGroup autoScalingGroup = autoScalingGroupsResponse.AutoScalingGroups[0];
Console.WriteLine($"Updating the auto scaling group {autoScalingGroup.AutoScalingGroupName} to remove the subnet in {azName}");
UpdateAutoScalingGroupResponse updateAutoScalingGroupResponse
= await asClient.UpdateAutoScalingGroupAsync(new UpdateAutoScalingGroupRequest
{
AutoScalingGroupName = autoScalingGroup.AutoScalingGroupName,
VPCZoneIdentifier = String.Join(",", autoScalingGroup.VPCZoneIdentifier.Split(',').Where(x => !subnetIdsInSpecifiedAZ.Contains(x)))
});
}
Console.WriteLine("Creating new network ACL associations");
await BlockSubnetsInAZ(vpcId, subnetIdsInSpecifiedAZ);
Console.WriteLine("Failing over database");
//fail over rds which is in the same AZ
DescribeDBInstancesResponse describeDBInstancesResult = await rdsClient.DescribeDBInstancesAsync();
string dbInstancedId = describeDBInstancesResult.DBInstances.Where(x => String.Equals(x.DBSubnetGroup.VpcId, vpcId, StringComparison.OrdinalIgnoreCase) &&
String.Equals(x.AvailabilityZone, azName, StringComparison.OrdinalIgnoreCase) &&
x.MultiAZ &&
!x.StatusInfos.Any())?.Select(x => x.DBInstanceIdentifier).FirstOrDefault();
// we want to fail over rds if rds is present in the same az where it is affected
if (!String.IsNullOrEmpty(dbInstancedId))
{
Console.WriteLine("Rebooting dbInstanceId to secondary AZ " + dbInstancedId);
var response = await rdsClient.RebootDBInstanceAsync(new RebootDBInstanceRequest()
{
DBInstanceIdentifier = dbInstancedId,
ForceFailover = true
});
}
else
{
Console.WriteLine($"Didn't find DB in the same AZ as {azName}");
}
Console.Write("Done");
}
catch (Exception exception)
{
Console.WriteLine("Unknown exception occurred " + exception.Message);
}
}
public async Task <IActionResult> Index(string action, string subnetID)
{
if (action.Equals("Delete") && !String.IsNullOrEmpty(subnetID))
{
Subnet Deletesubnet = await _context.Subnets.FindAsync(Int32.Parse(subnetID));
if (Deletesubnet == null)
{
TempData["Result"] = "Invaild Subnet!";
ChallengeNetworkParentViewModel model = new ChallengeNetworkParentViewModel
{
RetrievedSubnets = await _context.Subnets.ToListAsync(),
RetrievedRoutes = await _context.Routes.ToListAsync()
};
return(View(model));
}
else if (Deletesubnet.editable == false)
{
TempData["Result"] = "You cannot delete a default subnet!";
ChallengeNetworkParentViewModel model = new ChallengeNetworkParentViewModel
{
RetrievedSubnets = await _context.Subnets.ToListAsync(),
RetrievedRoutes = await _context.Routes.ToListAsync()
};
return(View(model));
}
else
{
DescribeSubnetsResponse response = await EC2Client.DescribeSubnetsAsync(new DescribeSubnetsRequest
{
Filters = new List <Amazon.EC2.Model.Filter>
{
new Filter("vpc-id", new List <string>
{
Deletesubnet.LinkedVPC.AWSVPCReference
})
}
});
Boolean flag = false;
for (int i = 0; i < response.Subnets.Count; i++)
{
Amazon.EC2.Model.Subnet subnet = response.Subnets[i];
String retrievedID = subnet.SubnetId;
if (Deletesubnet.AWSVPCSubnetReference.Equals(retrievedID))
{
flag = true;
break;
}
}
if (flag == false)
{
ViewData["Result"] = "Subnet not found! The subnet may have been modified by another user";
ChallengeNetworkParentViewModel model = new ChallengeNetworkParentViewModel
{
RetrievedSubnets = await _context.Subnets.ToListAsync(),
RetrievedRoutes = await _context.Routes.ToListAsync()
};
return(View(model));
}
else
{
try
{
List <RouteTable> RTs = await _context.RouteTables.ToListAsync();
DeleteSubnetRequest request = new DeleteSubnetRequest(Deletesubnet.AWSVPCSubnetReference);
DeleteSubnetResponse responseEC2 = await EC2Client.DeleteSubnetAsync(request);
if (responseEC2.HttpStatusCode == HttpStatusCode.OK)
{
_context.Subnets.Remove(Deletesubnet);
await _context.SaveChangesAsync();
TempData["Result"] = "Successfully Deleted!";
ChallengeNetworkParentViewModel model = new ChallengeNetworkParentViewModel
{
RetrievedSubnets = await _context.Subnets.ToListAsync(),
RetrievedRoutes = await _context.Routes.ToListAsync()
};
return(View(model));
}
else
{
TempData["Result"] = "Failed!";
ChallengeNetworkParentViewModel model = new ChallengeNetworkParentViewModel
{
RetrievedSubnets = await _context.Subnets.ToListAsync(),
RetrievedRoutes = await _context.Routes.ToListAsync()
};
return(View(model));
}
}
catch (AmazonEC2Exception e)
{
TempData["Result"] = e.Message;
ChallengeNetworkParentViewModel model = new ChallengeNetworkParentViewModel
{
RetrievedSubnets = await _context.Subnets.ToListAsync(),
RetrievedRoutes = await _context.Routes.ToListAsync()
};
return(View(model));
}
}
}
}
else if (action.Equals("Modify") && !String.IsNullOrEmpty(subnetID))
{
var Modifysubnet = await _context.Subnets.FindAsync(Int32.Parse(subnetID));
if (Modifysubnet.editable == false)
{
ViewData["Result"] = "You cannot modify a default subnet!";
ChallengeNetworkParentViewModel model = new ChallengeNetworkParentViewModel
{
RetrievedSubnets = await _context.Subnets.ToListAsync(),
RetrievedRoutes = await _context.Routes.ToListAsync()
};
return(View(model));
}
return(RedirectToAction("Edit", new { id = subnetID }));
}
else
{
ChallengeNetworkParentViewModel model = new ChallengeNetworkParentViewModel
{
RetrievedSubnets = await _context.Subnets.ToListAsync(),
RetrievedRoutes = await _context.Routes.ToListAsync()
};
return(View(model));
}
}
public async Task <IActionResult> Create([Bind("Name,Type,IPv4CIDR,SubnetSize")] Subnet subnet)
{
if (ModelState.IsValid)
{
subnet.editable = true;
switch (Int32.Parse(subnet.SubnetSize))
{
case 32766:
subnet.IPv4CIDR = subnet.IPv4CIDR + "/17";
break;
case 16382:
subnet.IPv4CIDR = subnet.IPv4CIDR + "/18";
break;
case 8190:
subnet.IPv4CIDR = subnet.IPv4CIDR + "/19";
break;
case 4094:
subnet.IPv4CIDR = subnet.IPv4CIDR + "/20";
break;
case 2046:
subnet.IPv4CIDR = subnet.IPv4CIDR + "/21";
break;
case 1022:
subnet.IPv4CIDR = subnet.IPv4CIDR + "/22";
break;
case 510:
subnet.IPv4CIDR = subnet.IPv4CIDR + "/23";
break;
case 254:
subnet.IPv4CIDR = subnet.IPv4CIDR + "/24";
break;
case 126:
subnet.IPv4CIDR = subnet.IPv4CIDR + "/25";
break;
case 62:
subnet.IPv4CIDR = subnet.IPv4CIDR + "/26";
break;
case 30:
subnet.IPv4CIDR = subnet.IPv4CIDR + "/27";
break;
case 14:
subnet.IPv4CIDR = subnet.IPv4CIDR + "/28";
break;
case 6:
subnet.IPv4CIDR = subnet.IPv4CIDR + "/29";
break;
case 2:
subnet.IPv4CIDR = subnet.IPv4CIDR + "/30";
break;
default:
ViewData["Exception"] = "Input Invaild!";
return(View());
}
VPC vpc = await _context.VPCs.FindAsync(1);
subnet.VPCID = vpc.ID;
DescribeSubnetsResponse response = await EC2Client.DescribeSubnetsAsync(new DescribeSubnetsRequest
{
Filters = new List <Amazon.EC2.Model.Filter>
{
new Amazon.EC2.Model.Filter {
Name = "vpc-id", Values = new List <string> {
vpc.AWSVPCReference
}
}
}
});
List <int> ipv6CIDR = new List <int>();
List <Amazon.EC2.Model.Subnet> subnets = response.Subnets;
int ipv6Subnet = 0;
string[] ipv6CIDRstr = new string[6];
DescribeVpcsResponse responseV = await EC2Client.DescribeVpcsAsync(new DescribeVpcsRequest
{
Filters = new List <Amazon.EC2.Model.Filter>
{
new Amazon.EC2.Model.Filter {
Name = "vpc-id", Values = new List <string> {
vpc.AWSVPCReference
}
}
}
});
Vpc vpcR = responseV.Vpcs[0];
VpcIpv6CidrBlockAssociation ipv6CidrBlockAssociation = vpcR.Ipv6CidrBlockAssociationSet[0];
ipv6CIDRstr = ipv6CidrBlockAssociation.Ipv6CidrBlock.Split(":");
if (subnets.Count != 0)
{
foreach (Amazon.EC2.Model.Subnet s in subnets)
{
List <SubnetIpv6CidrBlockAssociation> ipv6 = s.Ipv6CidrBlockAssociationSet;
ipv6CIDRstr = ipv6.ElementAt(0).Ipv6CidrBlock.Split(":");
ipv6Subnet = int.Parse(ipv6CIDRstr[3].Substring(2, 2), System.Globalization.NumberStyles.HexNumber);
ipv6CIDR.Add(ipv6Subnet);
}
Boolean flag = false;
while (flag != true)
{
Console.WriteLine("Doing while loop");
Console.WriteLine(ipv6Subnet);
Boolean passed = false;
++ipv6Subnet;
foreach (int i in ipv6CIDR)
{
if (ipv6Subnet <= ipv6CIDR[i])
{
passed = false;
break;
}
else
{
passed = true;
}
}
if (passed == true)
{
flag = true;
}
}
}
if (ipv6CIDRstr[5].Equals("/56"))
{
if (ipv6Subnet < 9)
{
subnet.IPv6CIDR = ipv6CIDRstr[0] + ":" + ipv6CIDRstr[1] + ":" + ipv6CIDRstr[2] + ":" + ipv6CIDRstr[3].Substring(0, 2) + "0" + ipv6Subnet.ToString() + "::/64";
}
else
{
subnet.IPv6CIDR = ipv6CIDRstr[0] + ":" + ipv6CIDRstr[1] + ":" + ipv6CIDRstr[2] + ":" + ipv6CIDRstr[3].Substring(0, 2) + Convert.ToInt32(ipv6Subnet).ToString() + "::/64";
}
}
else
{
if (ipv6Subnet < 9)
{
subnet.IPv6CIDR = ipv6CIDRstr[0] + ":" + ipv6CIDRstr[1] + ":" + ipv6CIDRstr[2] + ":" + ipv6CIDRstr[3].Substring(0, 2) + "0" + ipv6Subnet.ToString() + "::" + ipv6CIDRstr[5];
}
else
{
subnet.IPv6CIDR = ipv6CIDRstr[0] + ":" + ipv6CIDRstr[1] + ":" + ipv6CIDRstr[2] + ":" + ipv6CIDRstr[3].Substring(0, 2) + Convert.ToInt32(ipv6Subnet).ToString() + "::" + ipv6CIDRstr[5];
}
}
CreateSubnetRequest requestS = new CreateSubnetRequest()
{
CidrBlock = subnet.IPv4CIDR,
VpcId = vpc.AWSVPCReference,
Ipv6CidrBlock = subnet.IPv6CIDR
};
try
{
CreateSubnetResponse responseS = await EC2Client.CreateSubnetAsync(requestS);
if (responseS.HttpStatusCode == HttpStatusCode.OK)
{
subnet.AWSVPCSubnetReference = responseS.Subnet.SubnetId;
await EC2Client.CreateTagsAsync(new CreateTagsRequest
{
Resources = new List <string>
{
responseS.Subnet.SubnetId
},
Tags = new List <Tag>
{
new Tag("Name", subnet.Name)
}
});
AssociateRouteTableRequest requestRT = new AssociateRouteTableRequest
{
SubnetId = responseS.Subnet.SubnetId,
};
if (subnet.Type == Models.SubnetType.Internet)
{
RouteTable Internet = await _context.RouteTables.FindAsync(2);
requestRT.RouteTableId = Internet.AWSVPCRouteTableReference;
subnet.RouteTableID = Internet.ID;
await EC2Client.ModifySubnetAttributeAsync(new ModifySubnetAttributeRequest
{
SubnetId = responseS.Subnet.SubnetId,
MapPublicIpOnLaunch = true
});
await EC2Client.ModifySubnetAttributeAsync(new ModifySubnetAttributeRequest
{
SubnetId = responseS.Subnet.SubnetId,
AssignIpv6AddressOnCreation = true
});
}
else if (subnet.Type == Models.SubnetType.Extranet)
{
RouteTable Extranet = await _context.RouteTables.FindAsync(3);
requestRT.RouteTableId = Extranet.AWSVPCRouteTableReference;
subnet.RouteTableID = Extranet.ID;
}
else if (subnet.Type == Models.SubnetType.Intranet)
{
RouteTable Intranet = await _context.RouteTables.FindAsync(2);
requestRT.RouteTableId = Intranet.AWSVPCRouteTableReference;
subnet.RouteTableID = Intranet.ID;
}
AssociateRouteTableResponse responseRT = await EC2Client.AssociateRouteTableAsync(requestRT);
if (responseRT.HttpStatusCode == HttpStatusCode.OK)
{
subnet.AWSVPCRouteTableAssoicationID = responseRT.AssociationId;
_context.Subnets.Add(subnet);
await _context.SaveChangesAsync();
TempData["Result"] = "Successfully Created!";
return(RedirectToAction("Index"));
}
else
{
await EC2Client.DeleteSubnetAsync(new DeleteSubnetRequest
{
SubnetId = subnet.AWSVPCSubnetReference
});
DescribeVpcsResponse responseD = await EC2Client.DescribeVpcsAsync(new DescribeVpcsRequest
{
Filters = new List <Amazon.EC2.Model.Filter>
{
new Amazon.EC2.Model.Filter {
Name = "vpc-id", Values = new List <string> {
vpc.AWSVPCReference
}
}
}
});
String[] IPBlocks = responseD.Vpcs[0].CidrBlock.Split(".");
ViewData["IPCIDR"] = IPBlocks[0] + "." + IPBlocks[1];
ViewData["Exception"] = "Failed to Create!";
return(View());
}
}
else
{
DescribeVpcsResponse responseD = await EC2Client.DescribeVpcsAsync(new DescribeVpcsRequest
{
Filters = new List <Amazon.EC2.Model.Filter>
{
new Amazon.EC2.Model.Filter {
Name = "vpc-id", Values = new List <string> {
vpc.AWSVPCReference
}
}
}
});
String[] IPBlocks = responseD.Vpcs[0].CidrBlock.Split(".");
ViewData["IPCIDR"] = IPBlocks[0] + "." + IPBlocks[1];
ViewData["Exception"] = "Failed to Create!";
ViewData["Exception"] = "Failed to Create!";
return(View());
}
}
catch (Amazon.EC2.AmazonEC2Exception e)
{
DescribeVpcsResponse responseD = await EC2Client.DescribeVpcsAsync(new DescribeVpcsRequest
{
Filters = new List <Amazon.EC2.Model.Filter>
{
new Amazon.EC2.Model.Filter {
Name = "vpc-id", Values = new List <string> {
vpc.AWSVPCReference
}
}
}
});
String[] IPBlocks = responseD.Vpcs[0].CidrBlock.Split(".");
ViewData["IPCIDR"] = IPBlocks[0] + "." + IPBlocks[1];
ViewData["Exception"] = "Failed to Create!";
ViewData["Exception"] = e.Message;
return(View());
}
}
else
{
return(View());
}
}
