@gugananuvem/aws-local-simulator 1.0.35 → 1.0.39

package/src/services/vpc/server.js

@@ -0,0 +1,836 @@
+/**
+ * VPC Server
+ * Gerencia o servidor HTTP e as rotas do VPC
+ */
+
+const express = require('express');
+const logger = require('../../utils/logger');
+const EC2ResponseFormatter = require('./ec2ResponseFormatter');
+
+class VPCServer {
+  constructor(port, config) {
+    this.port = port;
+    this.config = config;
+    this.app = express();
+    this.simulator = null;
+  }
+
+  setupMiddlewares() {
+    this.app.use(express.json());
+    this.app.use(express.urlencoded({ extended: true }));
+  }
+
+  async initialize() {
+    logger.debug(`Inicializando VPC Server na porta ${this.port}`);
+    this.setupMiddlewares();
+    this.setupRoutes();
+  }
+
+  setupRoutes() {
+    // ========== VPC Routes ==========
+    
+    // Criar VPC
+    this.app.post('/__admin/vpcs/create', (req, res) => {
+      try {
+        const { CidrBlock, Tags, EnableDnsHostnames, EnableDnsSupport } = req.body;
+
+        if (!CidrBlock) {
+          return res.status(400).json({ error: 'CidrBlock is required' });
+        }
+
+        const vpc = this.simulator.createVPC(CidrBlock, Tags || [], {
+          EnableDnsHostnames,
+          EnableDnsSupport
+        });
+
+        res.json({ Vpc: vpc.toJSON() });
+      } catch (error) {
+        logger.error(`Error creating VPC: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Listar VPCs
+    this.app.get('/__admin/vpcs', (req, res) => {
+      try {
+        const filters = {};
+        if (req.query.vpcIds) {
+          filters.vpcIds = Array.isArray(req.query.vpcIds)
+            ? req.query.vpcIds
+            : [req.query.vpcIds];
+        }
+
+        const vpcs = this.simulator.describeVPCs(filters);
+        res.json({ Vpcs: vpcs.map(v => v.toJSON()) });
+      } catch (error) {
+        logger.error(`Error listing VPCs: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Obter VPC específico
+    this.app.get('/__admin/vpcs/:vpcId', (req, res) => {
+      try {
+        const vpc = this.simulator.getVPC(req.params.vpcId);
+        res.json({ Vpc: vpc.toJSON() });
+      } catch (error) {
+        logger.error(`Error getting VPC: ${error.message}`);
+        res.status(404).json({ error: error.message });
+      }
+    });
+
+    // Deletar VPC
+    this.app.delete('/__admin/vpcs/:vpcId', (req, res) => {
+      try {
+        this.simulator.deleteVPC(req.params.vpcId);
+        res.json({ success: true });
+      } catch (error) {
+        logger.error(`Error deleting VPC: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Modificar atributos VPC
+    this.app.post('/__admin/vpcs/:vpcId/attributes', (req, res) => {
+      try {
+        const { attribute, value } = req.body;
+
+        if (!attribute) {
+          return res.status(400).json({ error: 'Attribute is required' });
+        }
+
+        const vpc = this.simulator.modifyVPCAttribute(req.params.vpcId, attribute, value);
+        res.json({ Vpc: vpc.toJSON() });
+      } catch (error) {
+        logger.error(`Error modifying VPC attribute: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // ========== Subnet Routes ==========
+
+    // Criar Subnet
+    this.app.post('/__admin/subnets/create', (req, res) => {
+      try {
+        const { VpcId, CidrBlock, AvailabilityZone, Tags, MapPublicIpOnLaunch } = req.body;
+
+        if (!VpcId || !CidrBlock || !AvailabilityZone) {
+          return res
+            .status(400)
+            .json({ error: 'VpcId, CidrBlock and AvailabilityZone are required' });
+        }
+
+        const subnet = this.simulator.createSubnet(
+          VpcId,
+          CidrBlock,
+          AvailabilityZone,
+          Tags || [],
+          { MapPublicIpOnLaunch }
+        );
+
+        res.json({ Subnet: subnet.toJSON() });
+      } catch (error) {
+        logger.error(`Error creating Subnet: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Listar Subnets
+    this.app.get('/__admin/subnets', (req, res) => {
+      try {
+        const filters = {};
+        if (req.query.vpcIds) {
+          filters.vpcIds = Array.isArray(req.query.vpcIds)
+            ? req.query.vpcIds
+            : [req.query.vpcIds];
+        }
+
+        const subnets = this.simulator.describeSubnets(filters);
+        res.json({ Subnets: subnets.map(s => s.toJSON()) });
+      } catch (error) {
+        logger.error(`Error listing Subnets: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Obter Subnet
+    this.app.get('/__admin/subnets/:subnetId', (req, res) => {
+      try {
+        const subnet = this.simulator.getSubnet(req.params.subnetId);
+        res.json({ Subnet: subnet.toJSON() });
+      } catch (error) {
+        logger.error(`Error getting Subnet: ${error.message}`);
+        res.status(404).json({ error: error.message });
+      }
+    });
+
+    // Deletar Subnet
+    this.app.delete('/__admin/subnets/:subnetId', (req, res) => {
+      try {
+        this.simulator.deleteSubnet(req.params.subnetId);
+        res.json({ success: true });
+      } catch (error) {
+        logger.error(`Error deleting Subnet: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // ========== Route Table Routes ==========
+
+    // Criar Route Table
+    this.app.post('/__admin/route-tables/create', (req, res) => {
+      try {
+        const { VpcId, Tags } = req.body;
+
+        if (!VpcId) {
+          return res.status(400).json({ error: 'VpcId is required' });
+        }
+
+        const routeTable = this.simulator.createRouteTable(VpcId, Tags || []);
+        res.json({ RouteTable: routeTable.toJSON() });
+      } catch (error) {
+        logger.error(`Error creating Route Table: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Listar Route Tables
+    this.app.get('/__admin/route-tables', (req, res) => {
+      try {
+        const filters = {};
+        if (req.query.vpcIds) {
+          filters.vpcIds = Array.isArray(req.query.vpcIds)
+            ? req.query.vpcIds
+            : [req.query.vpcIds];
+        }
+
+        const routeTables = this.simulator.describeRouteTables(filters);
+        res.json({ RouteTables: routeTables.map(rt => rt.toJSON()) });
+      } catch (error) {
+        logger.error(`Error listing Route Tables: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Obter Route Table
+    this.app.get('/__admin/route-tables/:rtId', (req, res) => {
+      try {
+        const routeTable = this.simulator.getRouteTable(req.params.rtId);
+        res.json({ RouteTable: routeTable.toJSON() });
+      } catch (error) {
+        logger.error(`Error getting Route Table: ${error.message}`);
+        res.status(404).json({ error: error.message });
+      }
+    });
+
+    // Deletar Route Table
+    this.app.delete('/__admin/route-tables/:rtId', (req, res) => {
+      try {
+        this.simulator.deleteRouteTable(req.params.rtId);
+        res.json({ success: true });
+      } catch (error) {
+        logger.error(`Error deleting Route Table: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Adicionar Rota
+    this.app.post('/__admin/route-tables/:rtId/routes', (req, res) => {
+      try {
+        const { DestinationCidrBlock, Target, TargetType } = req.body;
+
+        if (!DestinationCidrBlock || !Target) {
+          return res
+            .status(400)
+            .json({ error: 'DestinationCidrBlock and Target are required' });
+        }
+
+        const route = this.simulator.addRoute(
+          req.params.rtId,
+          DestinationCidrBlock,
+          Target,
+          TargetType || 'igw'
+        );
+
+        res.json({ Route: route.toJSON() });
+      } catch (error) {
+        logger.error(`Error adding route: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Remover Rota
+    this.app.delete('/__admin/route-tables/:rtId/routes/:cidr', (req, res) => {
+      try {
+        const cidr = decodeURIComponent(req.params.cidr);
+        this.simulator.removeRoute(req.params.rtId, cidr);
+        res.json({ success: true });
+      } catch (error) {
+        logger.error(`Error removing route: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Associar Route Table com Subnet
+    this.app.post('/__admin/route-tables/:rtId/associations', (req, res) => {
+      try {
+        const { SubnetId } = req.body;
+
+        if (!SubnetId) {
+          return res.status(400).json({ error: 'SubnetId is required' });
+        }
+
+        const association = this.simulator.associateRouteTable(req.params.rtId, SubnetId);
+        res.json({ Association: association.toJSON() });
+      } catch (error) {
+        logger.error(`Error associating route table: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Desassociar Route Table
+    this.app.delete('/__admin/route-tables/:rtId/associations/:subnetId', (req, res) => {
+      try {
+        this.simulator.disassociateRouteTable(req.params.rtId, req.params.subnetId);
+        res.json({ success: true });
+      } catch (error) {
+        logger.error(`Error disassociating route table: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // ========== Internet Gateway Routes ==========
+
+    // Criar Internet Gateway
+    this.app.post('/__admin/internet-gateways/create', (req, res) => {
+      try {
+        const { Tags } = req.body;
+        const igw = this.simulator.createInternetGateway(Tags || []);
+        res.json({ InternetGateway: igw.toJSON() });
+      } catch (error) {
+        logger.error(`Error creating IGW: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Listar Internet Gateways
+    this.app.get('/__admin/internet-gateways', (req, res) => {
+      try {
+        const igws = this.simulator.describeInternetGateways();
+        res.json({ InternetGateways: igws.map(igw => igw.toJSON()) });
+      } catch (error) {
+        logger.error(`Error listing IGWs: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Obter Internet Gateway
+    this.app.get('/__admin/internet-gateways/:igwId', (req, res) => {
+      try {
+        const igw = this.simulator.getInternetGateway(req.params.igwId);
+        res.json({ InternetGateway: igw.toJSON() });
+      } catch (error) {
+        logger.error(`Error getting IGW: ${error.message}`);
+        res.status(404).json({ error: error.message });
+      }
+    });
+
+    // Anexar IGW
+    this.app.post('/__admin/internet-gateways/:igwId/attach', (req, res) => {
+      try {
+        const { VpcId } = req.body;
+
+        if (!VpcId) {
+          return res.status(400).json({ error: 'VpcId is required' });
+        }
+
+        const attachment = this.simulator.attachInternetGateway(req.params.igwId, VpcId);
+        res.json({ Attachment: attachment.toJSON() });
+      } catch (error) {
+        logger.error(`Error attaching IGW: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Desanexar IGW
+    this.app.post('/__admin/internet-gateways/:igwId/detach', (req, res) => {
+      try {
+        const { VpcId } = req.body;
+
+        if (!VpcId) {
+          return res.status(400).json({ error: 'VpcId is required' });
+        }
+
+        this.simulator.detachInternetGateway(req.params.igwId, VpcId);
+        res.json({ success: true });
+      } catch (error) {
+        logger.error(`Error detaching IGW: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Deletar IGW
+    this.app.delete('/__admin/internet-gateways/:igwId', (req, res) => {
+      try {
+        this.simulator.deleteInternetGateway(req.params.igwId);
+        res.json({ success: true });
+      } catch (error) {
+        logger.error(`Error deleting IGW: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // ========== VPC Endpoint Routes ==========
+
+    // Criar VPC Endpoint
+    this.app.post('/__admin/vpc-endpoints/create', (req, res) => {
+      try {
+        const { VpcId, ServiceName, VpcEndpointType, RouteTableIds, SubnetIds } = req.body;
+
+        if (!VpcId || !ServiceName) {
+          return res.status(400).json({ error: 'VpcId and ServiceName are required' });
+        }
+
+        const endpoint = this.simulator.createVPCEndpoint(VpcId, ServiceName, {
+          VpcEndpointType,
+          RouteTableIds,
+          SubnetIds
+        });
+
+        res.json({ VpcEndpoint: endpoint.toJSON() });
+      } catch (error) {
+        logger.error(`Error creating VPC Endpoint: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Listar VPC Endpoints
+    this.app.get('/__admin/vpc-endpoints', (req, res) => {
+      try {
+        const filters = {};
+        if (req.query.vpcIds) {
+          filters.vpcIds = Array.isArray(req.query.vpcIds)
+            ? req.query.vpcIds
+            : [req.query.vpcIds];
+        }
+
+        const endpoints = this.simulator.describeVPCEndpoints(filters);
+        res.json({ VpcEndpoints: endpoints.map(e => e.toJSON()) });
+      } catch (error) {
+        logger.error(`Error listing VPC Endpoints: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Obter VPC Endpoint
+    this.app.get('/__admin/vpc-endpoints/:epId', (req, res) => {
+      try {
+        const endpoint = this.simulator.getVPCEndpoint(req.params.epId);
+        res.json({ VpcEndpoint: endpoint.toJSON() });
+      } catch (error) {
+        logger.error(`Error getting VPC Endpoint: ${error.message}`);
+        res.status(404).json({ error: error.message });
+      }
+    });
+
+    // Modificar VPC Endpoint
+    this.app.post('/__admin/vpc-endpoints/:epId/modify', (req, res) => {
+      try {
+        const changes = req.body;
+        const endpoint = this.simulator.modifyVPCEndpoint(req.params.epId, changes);
+        res.json({ VpcEndpoint: endpoint.toJSON() });
+      } catch (error) {
+        logger.error(`Error modifying VPC Endpoint: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Deletar VPC Endpoint
+    this.app.delete('/__admin/vpc-endpoints/:epId', (req, res) => {
+      try {
+        this.simulator.deleteVPCEndpoint(req.params.epId);
+        res.json({ success: true });
+      } catch (error) {
+        logger.error(`Error deleting VPC Endpoint: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // ========== Health Check ==========
+
+    this.app.get('/__admin/health', (req, res) => {
+      res.json({ status: 'ok', service: 'vpc' });
+    });
+
+    // Listar todos os recursos
+    this.app.get('/__admin/resources', (req, res) => {
+      try {
+        const resources = this.simulator.getAllResources();
+        res.json({
+          vpcs: resources.vpcs.map(v => v.toJSON()),
+          subnets: resources.subnets.map(s => s.toJSON()),
+          routeTables: resources.routeTables.map(rt => rt.toJSON()),
+          internetGateways: resources.internetGateways.map(igw => igw.toJSON()),
+          vpcEndpoints: resources.vpcEndpoints.map(e => e.toJSON()),
+          natGateways: resources.natGateways.map(ng => ng.toJSON())
+        });
+      } catch (error) {
+        logger.error(`Error fetching resources: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // ========== EC2 Query Protocol Internal Routes ==========
+    // (Kept for backward compatibility with REST API)
+    // These routes are now also handled by the catch-all POST / handler above
+
+    // DeleteRouteTable
+    this.app.post('/__internal/delete-route-table', (req, res) => {
+      try {
+        const routeTableId = req.body.RouteTableId;
+        if (!routeTableId) {
+          throw new Error('RouteTableId is required');
+        }
+
+        this.simulator.deleteRouteTable(routeTableId);
+        const xmlResponse = EC2ResponseFormatter.formatDeleteRouteTableResponse();
+        res.set('Content-Type', 'text/xml');
+        res.send(xmlResponse);
+      } catch (error) {
+        logger.error(`Error deleting Route Table: ${error.message}`);
+        const xmlError = EC2ResponseFormatter.formatErrorResponse('InternalError', error.message);
+        res.status(400).set('Content-Type', 'text/xml').send(xmlError);
+      }
+    });
+
+    // Catch-all POST / for EC2 Query Protocol (AWS CLI)
+    this.app.post('/', (req, res) => {
+      try {
+        const action = req.body?.Action || '';
+        logger.debug(`EC2 Query Protocol Action: ${action}`);
+
+        // Mapear ações EC2 para handlers
+        switch (action) {
+          case 'DescribeVpcs':
+            return this._handleDescribeVpcs(req, res);
+          case 'CreateVpc':
+            return this._handleCreateVpc(req, res);
+          case 'DeleteVpc':
+            return this._handleDeleteVpc(req, res);
+          case 'DescribeSubnets':
+            return this._handleDescribeSubnets(req, res);
+          case 'CreateSubnet':
+            return this._handleCreateSubnet(req, res);
+          case 'DeleteSubnet':
+            return this._handleDeleteSubnet(req, res);
+          case 'DescribeInternetGateways':
+            return this._handleDescribeIgws(req, res);
+          case 'CreateInternetGateway':
+            return this._handleCreateIgw(req, res);
+          case 'AttachInternetGateway':
+            return this._handleAttachIgw(req, res);
+          case 'DetachInternetGateway':
+            return this._handleDetachIgw(req, res);
+          case 'DeleteInternetGateway':
+            return this._handleDeleteIgw(req, res);
+          case 'DescribeRouteTables':
+            return this._handleDescribeRouteTables(req, res);
+          case 'CreateRouteTable':
+            return this._handleCreateRouteTable(req, res);
+          case 'CreateRoute':
+            return this._handleCreateRoute(req, res);
+          case 'DeleteRouteTable':
+            return this._handleDeleteRouteTable(req, res);
+          default:
+            const xmlError = EC2ResponseFormatter.formatErrorResponse(
+              'InvalidAction',
+              `Unknown Action: ${action}`
+            );
+            res.status(400).set('Content-Type', 'text/xml').send(xmlError);
+        }
+      } catch (error) {
+        logger.error(`Error handling EC2 Query: ${error.message}`);
+        const xmlError = EC2ResponseFormatter.formatErrorResponse('InternalError', error.message);
+        res.status(500).set('Content-Type', 'text/xml').send(xmlError);
+      }
+    });
+  }
+
+  // EC2 Query Protocol handlers
+  _handleDescribeVpcs(req, res) {
+    try {
+      const vpcs = this.simulator.describeVPCs();
+      const xmlResponse = EC2ResponseFormatter.formatDescribeVpcsResponse(
+        vpcs.map(vpc => vpc.toJSON())
+      );
+      res.set('Content-Type', 'text/xml');
+      res.send(xmlResponse);
+    } catch (error) {
+      logger.error(`Error describing VPCs: ${error.message}`);
+      const xmlError = EC2ResponseFormatter.formatErrorResponse('InternalError', error.message);
+      res.status(400).set('Content-Type', 'text/xml').send(xmlError);
+    }
+  }
+
+  _handleCreateVpc(req, res) {
+    try {
+      const cidrBlock = req.body.CidrBlock;
+      if (!cidrBlock) {
+        throw new Error('CidrBlock is required');
+      }
+
+      const vpc = this.simulator.createVPC(cidrBlock);
+      const xmlResponse = EC2ResponseFormatter.formatCreateVpcResponse(vpc.toJSON());
+      res.set('Content-Type', 'text/xml');
+      res.send(xmlResponse);
+    } catch (error) {
+      logger.error(`Error creating VPC: ${error.message}`);
+      const xmlError = EC2ResponseFormatter.formatErrorResponse('InternalError', error.message);
+      res.status(400).set('Content-Type', 'text/xml').send(xmlError);
+    }
+  }
+
+  _handleDeleteVpc(req, res) {
+    try {
+      const vpcId = req.body.VpcId;
+      if (!vpcId) {
+        throw new Error('VpcId is required');
+      }
+
+      this.simulator.deleteVPC(vpcId);
+      const xmlResponse = EC2ResponseFormatter.formatDeleteVpcResponse();
+      res.set('Content-Type', 'text/xml');
+      res.send(xmlResponse);
+    } catch (error) {
+      logger.error(`Error deleting VPC: ${error.message}`);
+      const xmlError = EC2ResponseFormatter.formatErrorResponse('InternalError', error.message);
+      res.status(400).set('Content-Type', 'text/xml').send(xmlError);
+    }
+  }
+
+  _handleDescribeSubnets(req, res) {
+    try {
+      const subnets = this.simulator.describeSubnets();
+      const xmlResponse = EC2ResponseFormatter.formatDescribeSubnetsResponse(
+        subnets.map(subnet => subnet.toJSON())
+      );
+      res.set('Content-Type', 'text/xml');
+      res.send(xmlResponse);
+    } catch (error) {
+      logger.error(`Error describing Subnets: ${error.message}`);
+      const xmlError = EC2ResponseFormatter.formatErrorResponse('InternalError', error.message);
+      res.status(400).set('Content-Type', 'text/xml').send(xmlError);
+    }
+  }
+
+  _handleCreateSubnet(req, res) {
+    try {
+      const { VpcId, CidrBlock, AvailabilityZone } = req.body;
+      if (!VpcId || !CidrBlock || !AvailabilityZone) {
+        throw new Error('VpcId, CidrBlock and AvailabilityZone are required');
+      }
+
+      const subnet = this.simulator.createSubnet(VpcId, CidrBlock, AvailabilityZone);
+      const xmlResponse = EC2ResponseFormatter.formatCreateSubnetResponse(subnet.toJSON());
+      res.set('Content-Type', 'text/xml');
+      res.send(xmlResponse);
+    } catch (error) {
+      logger.error(`Error creating Subnet: ${error.message}`);
+      const xmlError = EC2ResponseFormatter.formatErrorResponse('InternalError', error.message);
+      res.status(400).set('Content-Type', 'text/xml').send(xmlError);
+    }
+  }
+
+  _handleDeleteSubnet(req, res) {
+    try {
+      const subnetId = req.body.SubnetId;
+      if (!subnetId) {
+        throw new Error('SubnetId is required');
+      }
+
+      this.simulator.deleteSubnet(subnetId);
+      const xmlResponse = EC2ResponseFormatter.formatDeleteSubnetResponse();
+      res.set('Content-Type', 'text/xml');
+      res.send(xmlResponse);
+    } catch (error) {
+      logger.error(`Error deleting Subnet: ${error.message}`);
+      const xmlError = EC2ResponseFormatter.formatErrorResponse('InternalError', error.message);
+      res.status(400).set('Content-Type', 'text/xml').send(xmlError);
+    }
+  }
+
+  _handleDescribeIgws(req, res) {
+    try {
+      const igws = this.simulator.describeInternetGateways();
+      const xmlResponse = EC2ResponseFormatter.formatDescribeIgwResponse(
+        igws.map(igw => igw.toJSON())
+      );
+      res.set('Content-Type', 'text/xml');
+      res.send(xmlResponse);
+    } catch (error) {
+      logger.error(`Error describing IGWs: ${error.message}`);
+      const xmlError = EC2ResponseFormatter.formatErrorResponse('InternalError', error.message);
+      res.status(400).set('Content-Type', 'text/xml').send(xmlError);
+    }
+  }
+
+  _handleCreateIgw(req, res) {
+    try {
+      const igw = this.simulator.createInternetGateway();
+      const xmlResponse = EC2ResponseFormatter.formatCreateIgwResponse(igw.toJSON());
+      res.set('Content-Type', 'text/xml');
+      res.send(xmlResponse);
+    } catch (error) {
+      logger.error(`Error creating IGW: ${error.message}`);
+      const xmlError = EC2ResponseFormatter.formatErrorResponse('InternalError', error.message);
+      res.status(400).set('Content-Type', 'text/xml').send(xmlError);
+    }
+  }
+
+  _handleAttachIgw(req, res) {
+    try {
+      const { InternetGatewayId, VpcId } = req.body;
+      if (!InternetGatewayId || !VpcId) {
+        throw new Error('InternetGatewayId and VpcId are required');
+      }
+
+      this.simulator.attachInternetGateway(InternetGatewayId, VpcId);
+      const xmlResponse = EC2ResponseFormatter.formatAttachIgwResponse();
+      res.set('Content-Type', 'text/xml');
+      res.send(xmlResponse);
+    } catch (error) {
+      logger.error(`Error attaching IGW: ${error.message}`);
+      const xmlError = EC2ResponseFormatter.formatErrorResponse('InternalError', error.message);
+      res.status(400).set('Content-Type', 'text/xml').send(xmlError);
+    }
+  }
+
+  _handleDetachIgw(req, res) {
+    try {
+      const { InternetGatewayId, VpcId } = req.body;
+      if (!InternetGatewayId || !VpcId) {
+        throw new Error('InternetGatewayId and VpcId are required');
+      }
+
+      this.simulator.detachInternetGateway(InternetGatewayId, VpcId);
+      const xmlResponse = EC2ResponseFormatter.formatDetachIgwResponse();
+      res.set('Content-Type', 'text/xml');
+      res.send(xmlResponse);
+    } catch (error) {
+      logger.error(`Error detaching IGW: ${error.message}`);
+      const xmlError = EC2ResponseFormatter.formatErrorResponse('InternalError', error.message);
+      res.status(400).set('Content-Type', 'text/xml').send(xmlError);
+    }
+  }
+
+  _handleDeleteIgw(req, res) {
+    try {
+      const internetGatewayId = req.body.InternetGatewayId;
+      if (!internetGatewayId) {
+        throw new Error('InternetGatewayId is required');
+      }
+
+      this.simulator.deleteInternetGateway(internetGatewayId);
+      const xmlResponse = EC2ResponseFormatter.formatDeleteIgwResponse();
+      res.set('Content-Type', 'text/xml');
+      res.send(xmlResponse);
+    } catch (error) {
+      logger.error(`Error deleting IGW: ${error.message}`);
+      const xmlError = EC2ResponseFormatter.formatErrorResponse('InternalError', error.message);
+      res.status(400).set('Content-Type', 'text/xml').send(xmlError);
+    }
+  }
+
+  _handleDescribeRouteTables(req, res) {
+    try {
+      const routeTables = this.simulator.describeRouteTables();
+      const xmlResponse = EC2ResponseFormatter.formatDescribeRouteTablesResponse(
+        routeTables.map(rt => rt.toJSON())
+      );
+      res.set('Content-Type', 'text/xml');
+      res.send(xmlResponse);
+    } catch (error) {
+      logger.error(`Error describing Route Tables: ${error.message}`);
+      const xmlError = EC2ResponseFormatter.formatErrorResponse('InternalError', error.message);
+      res.status(400).set('Content-Type', 'text/xml').send(xmlError);
+    }
+  }
+
+  _handleCreateRouteTable(req, res) {
+    try {
+      const vpcId = req.body.VpcId;
+      if (!vpcId) {
+        throw new Error('VpcId is required');
+      }
+
+      const routeTable = this.simulator.createRouteTable(vpcId);
+      const xmlResponse = EC2ResponseFormatter.formatCreateRouteTableResponse(
+        routeTable.toJSON()
+      );
+      res.set('Content-Type', 'text/xml');
+      res.send(xmlResponse);
+    } catch (error) {
+      logger.error(`Error creating Route Table: ${error.message}`);
+      const xmlError = EC2ResponseFormatter.formatErrorResponse('InternalError', error.message);
+      res.status(400).set('Content-Type', 'text/xml').send(xmlError);
+    }
+  }
+
+  _handleCreateRoute(req, res) {
+    try {
+      const { RouteTableId, DestinationCidrBlock, GatewayId } = req.body;
+      if (!RouteTableId || !DestinationCidrBlock || !GatewayId) {
+        throw new Error('RouteTableId, DestinationCidrBlock and GatewayId are required');
+      }
+
+      this.simulator.addRoute(RouteTableId, DestinationCidrBlock, GatewayId);
+      const xmlResponse = EC2ResponseFormatter.formatCreateRouteResponse();
+      res.set('Content-Type', 'text/xml');
+      res.send(xmlResponse);
+    } catch (error) {
+      logger.error(`Error creating Route: ${error.message}`);
+      const xmlError = EC2ResponseFormatter.formatErrorResponse('InternalError', error.message);
+      res.status(400).set('Content-Type', 'text/xml').send(xmlError);
+    }
+  }
+
+  _handleDeleteRouteTable(req, res) {
+    try {
+      const routeTableId = req.body.RouteTableId;
+      if (!routeTableId) {
+        throw new Error('RouteTableId is required');
+      }
+
+      this.simulator.deleteRouteTable(routeTableId);
+      const xmlResponse = EC2ResponseFormatter.formatDeleteRouteTableResponse();
+      res.set('Content-Type', 'text/xml');
+      res.send(xmlResponse);
+    } catch (error) {
+      logger.error(`Error deleting Route Table: ${error.message}`);
+      const xmlError = EC2ResponseFormatter.formatErrorResponse('InternalError', error.message);
+      res.status(400).set('Content-Type', 'text/xml').send(xmlError);
+    }
+  }
+
+  async start() {
+    return new Promise((resolve) => {
+      this.server = this.app.listen(this.port, () => {
+        logger.info(`VPC Server running on http://localhost:${this.port}`);
+        resolve();
+      });
+    });
+  }
+
+  async stop() {
+    if (this.server) {
+      return new Promise((resolve) => {
+        this.server.close(() => {
+          logger.info('VPC Server stopped');
+          resolve();
+        });
+      });
+    }
+  }
+}
+
+module.exports = VPCServer;