Beispiel #1
0
        protected override void ProcessRecord()
        {
            base.ProcessRecord();

            if (!ConfirmDelete("OCIVirtualNetworkSubnet", "Remove"))
            {
                return;
            }

            DeleteSubnetRequest request;

            try
            {
                request = new DeleteSubnetRequest
                {
                    SubnetId = SubnetId,
                    IfMatch  = IfMatch
                };

                response = client.DeleteSubnet(request).GetAwaiter().GetResult();
                WriteOutput(response);
                FinishProcessing(response);
            }
            catch (Exception ex)
            {
                TerminatingErrorDuringExecution(ex);
            }
        }
        private static void DeleteSubnet(VpcClient client)
        {
            var req = new DeleteSubnetRequest
            {
                VpcId    = "0fae9377-f51c-430e-ba16-9bdd619b1d97",
                SubnetId = "efa0d2e2-314f-44f2-99f6-ecfeaab3ba9d"
            };

            try
            {
                DeleteSubnetResponse resp = client.DeleteSubnet(req);
                Console.WriteLine(resp.HttpStatusCode);
            }
            catch (RequestTimeoutException requestTimeoutException)
            {
                Console.WriteLine(requestTimeoutException.ErrorMessage);
            }
            catch (ServiceResponseException clientRequestException)
            {
                Console.WriteLine(clientRequestException.HttpStatusCode);
                Console.WriteLine(clientRequestException.ErrorCode);
                Console.WriteLine(clientRequestException.ErrorMsg);
            }
            catch (ConnectionException connectionException)
            {
                Console.WriteLine(connectionException.ErrorMessage);
            }
        }
        public async Task <DeleteSubnetResponse> DeleteSubnetAsync(string subnetId)
        {
            var request  = new DeleteSubnetRequest(subnetId);
            var response = await _cloudComputeClient.DeleteSubnetAsync(request);

            return(response);
        }
        /**
         * Deletes a subnet and waits for it to be deleted.
         *
         * @param vcnClient the service client to use to delete the subnet
         * @param subnet the subnet to delete
         *
         * @throws Exception if there is an error waiting on the subnet to be deleted
         */
        private static async Task DeleteSubnet(VirtualNetworkClient virtualNetworkClient, Subnet subnet)
        {
            DeleteSubnetRequest deleteSubnetRequest = new DeleteSubnetRequest
            {
                SubnetId = subnet.Id
            };
            await virtualNetworkClient.DeleteSubnet(deleteSubnetRequest);

            logger.Info($"Deleted Subnet: {subnet.Id}");
        }
Beispiel #5
0
        /// <summary>
        /// 删除子网
        /// </summary>
        public async Task <DeleteSubnetResponse> DeleteSubnetAsync(DeleteSubnetRequest deleteSubnetRequest)
        {
            Dictionary <string, string> urlParam = new Dictionary <string, string>();

            urlParam.Add("vpc_id", deleteSubnetRequest.VpcId.ToString());
            urlParam.Add("subnet_id", deleteSubnetRequest.SubnetId.ToString());
            string              urlPath  = HttpUtils.AddUrlPath("/v1/{project_id}/vpcs/{vpc_id}/subnets/{subnet_id}", urlParam);
            SdkRequest          request  = HttpUtils.InitSdkRequest(urlPath, deleteSubnetRequest);
            HttpResponseMessage response = await DoHttpRequestAsync("DELETE", request);

            return(JsonUtils.DeSerializeNull <DeleteSubnetResponse>(response));
        }
        /**
         * Deletes a subnet and waits for it to be deleted.
         *
         * @param virtualNetworkClient the service client to use to delete the subnet
         * @param subnet the subnet to delete
         */
        private static async Task DeleteSubnet(VirtualNetworkClient virtualNetworkClient, Subnet subnet)
        {
            DeleteSubnetRequest deleteSubnetRequest = new DeleteSubnetRequest
            {
                SubnetId = subnet.Id
            };
            RetryConfiguration retryConfiguration = new RetryConfiguration
            {
                MaxAttempts = 5
            };
            await virtualNetworkClient.DeleteSubnet(deleteSubnetRequest, retryConfiguration);

            logger.Info($"Deleted Subnet: {subnet.Id}");
        }
Beispiel #7
0
        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));
            }
        }
Beispiel #8
0
 /// <summary>
 ///  删除子网
 /// </summary>
 /// <param name="request">请求参数信息</param>
 /// <returns>请求结果信息</returns>
 public async Task <DeleteSubnetResponse> DeleteSubnet(DeleteSubnetRequest request)
 {
     return(await new DeleteSubnetExecutor().Client(this).Execute <DeleteSubnetResponse, DeleteSubnetResult, DeleteSubnetRequest>(request).ConfigureAwait(false));
 }
Beispiel #9
0
 /// <summary>
 ///  删除子网
 /// </summary>
 /// <param name="request">请求参数信息</param>
 /// <returns>请求结果信息</returns>
 public DeleteSubnetResponse DeleteSubnet(DeleteSubnetRequest request)
 {
     return(new DeleteSubnetExecutor().Client(this).Execute <DeleteSubnetResponse, DeleteSubnetResult, DeleteSubnetRequest>(request));
 }
Beispiel #10
0
        public bool delete_vpc_all(string region_txt)
        {
            try
            {
                var client = get_client();
                write_log(region + " の VPC を確認しています。");
                var query_req = new DescribeVpcsRequest();
                query_req.Filters.Add(new Filter()
                {
                    Name = "tag-value", Values = new List <string>()
                    {
                        Helper.build_name(setting_, "vpc")
                    }
                });
                var query_res = client.DescribeVpcs(query_req);
                if (query_res.Vpcs.Count == 0)
                {
                    write_log(region + " の VPC が存在しませんでした。");
                    return(true);
                }
                vpc_id = query_res.Vpcs[0].VpcId;

                var query_instance_req = new DescribeInstancesRequest();
                var query_instance_res = client.DescribeInstances(query_instance_req);

                bool flg = true;
                foreach (var row in query_instance_res.Reservations)
                {
                    foreach (var row2 in row.Instances)
                    {
                        if (row2.State != null && row2.State.Code != 48 &&
                            row2.VpcId != null && row2.VpcId.Equals(vpc_id))
                        {
                            flg = false;
                            break;
                        }
                    }
                    if (flg == false)
                    {
                        break;
                    }
                }
                if (flg == false)
                {
                    write_log(region + " にはインスタンスが存在する為、VPC を削除できません。");
                    return(false);
                }

                write_log(region + " のセキュリティグループを確認しています。");

                var query_sg_req = new DescribeSecurityGroupsRequest();
                query_sg_req.Filters.Add(new Filter()
                {
                    Name = "tag-value", Values = new List <string>()
                    {
                        Helper.build_name(setting_, "sg")
                    }
                });
                var query_sg_res = client.DescribeSecurityGroups(query_sg_req);
                foreach (var row in query_sg_res.SecurityGroups)
                {
                    write_log("セキュリティグループ " + row.GroupId + " を削除しています。");
                    var delete_sg_req = new DeleteSecurityGroupRequest();
                    delete_sg_req.GroupId = row.GroupId;
                    client.DeleteSecurityGroup(delete_sg_req);
                }

                using (FileStream fs = new FileStream(region_txt, FileMode.Open, FileAccess.Read))
                {
                    IList <string> list = new List <string>(subnet_ids.Keys);
                    foreach (string tag in list)
                    {
                        if (Helper.check_az(fs, region, tag, 0) == false)
                        {
                            continue;
                        }
                        write_log(region + tag + " のサブネットを確認しています。");
                        var query_sub_req = new DescribeSubnetsRequest();
                        query_sub_req.Filters.Add(new Filter()
                        {
                            Name = "tag-value", Values = new List <string>()
                            {
                                Helper.build_name(setting_, "subnet_" + tag)
                            }
                        });
                        var query_sub_res = client.DescribeSubnets(query_sub_req);
                        foreach (var row in query_sub_res.Subnets)
                        {
                            write_log("サブネット " + row.SubnetId + " を削除しています。");
                            var delete_sub_req = new DeleteSubnetRequest();
                            delete_sub_req.SubnetId = row.SubnetId;
                            client.DeleteSubnet(delete_sub_req);
                        }
                    }
                }

                write_log(region + " のインターネットゲートウェイを確認しています。");

                var query_igw_req = new DescribeInternetGatewaysRequest();
                query_igw_req.Filters.Add(new Filter()
                {
                    Name = "tag-value", Values = new List <string>()
                    {
                        Helper.build_name(setting_, "igw")
                    }
                });
                var query_igw_res = client.DescribeInternetGateways(query_igw_req);
                foreach (var row in query_igw_res.InternetGateways)
                {
                    var detach_igw_req = new DetachInternetGatewayRequest();
                    detach_igw_req.InternetGatewayId = row.InternetGatewayId;
                    detach_igw_req.VpcId             = vpc_id;
                    client.DetachInternetGateway(detach_igw_req);

                    var delete_igw_req = new DeleteInternetGatewayRequest();
                    delete_igw_req.InternetGatewayId = row.InternetGatewayId;
                    client.DeleteInternetGateway(delete_igw_req);
                }

                write_log("VPC " + vpc_id + " を削除しています。");

                var delete_vpc_req = new DeleteVpcRequest();
                delete_vpc_req.VpcId = vpc_id;
                client.DeleteVpc(delete_vpc_req);
            }
            catch (Exception ex)
            {
                write_log("ERROR: " + ex.ToString());
                return(false);
            }
            return(true);
        }