@gugananuvem/aws-local-simulator 1.0.34 → 1.0.39

package/src/services/vpc/simulator.js

@@ -0,0 +1,613 @@
+/**
+ * VPC Simulator
+ * Gerencia o estado de VPCs, subnets, rotas e gateways com persistência
+ */
+
+const path = require('path');
+const { v4: uuidv4 } = require('uuid');
+const VPC = require('./models/vpc');
+const Subnet = require('./models/subnet');
+const { RouteTable } = require('./models/routeTable');
+const { InternetGateway } = require('./models/internetGateway');
+const VPCEndpoint = require('./models/vpcEndpoint');
+const {
+  NATGateway,
+  CustomerGateway,
+  VpnGateway,
+  VpnConnection
+} = require('./models/vpcGateway');
+const LocalStore = require('../../utils/local-store');
+const logger = require('../../utils/logger');
+
+class VPCSimulator {
+  constructor(config = {}) {
+    this.config = config;
+    this.vpcs = new Map();
+    this.subnets = new Map();
+    this.routeTables = new Map();
+    this.internetGateways = new Map();
+    this.vpcEndpoints = new Map();
+    this.natGateways = new Map();
+    this.customerGateways = new Map();
+    this.vpnGateways = new Map();
+    this.vpnConnections = new Map();
+
+    // Inicializar persistência
+    const dataDir = process.env.AWS_LOCAL_SIMULATOR_DATA_DIR || config.dataDir || './.aws-local-simulator-data';
+    this.dataDir = path.join(dataDir, 'vpc');
+    this.store = new LocalStore(this.dataDir);
+    this.isPersistent = true;
+  }
+
+  async initialize() {
+    // 1. Carregar dados persistidos se existirem
+    await this.loadFromPersistence();
+
+    // 2. Se não houver dados persistidos, carregar da configuração
+    if (this.vpcs.size === 0 && this.config.vpcs && Array.isArray(this.config.vpcs)) {
+      logger.info('📚 Carregando VPCs da configuração inicial...');
+      for (const vpcConfig of this.config.vpcs) {
+        this.createVPC(vpcConfig.CidrBlock, vpcConfig.Tags || []);
+      }
+    }
+
+    if (this.subnets.size === 0 && this.config.subnets && Array.isArray(this.config.subnets)) {
+      for (const subnetConfig of this.config.subnets) {
+        this.createSubnet(
+          subnetConfig.VpcId,
+          subnetConfig.CidrBlock,
+          subnetConfig.AvailabilityZone,
+          subnetConfig.Tags
+        );
+      }
+    }
+  }
+
+  /**
+   * Carrega dados persistidos do storage
+   */
+  async loadFromPersistence() {
+    try {
+      // Carregar VPCs
+      const vpcsData = this.store.read('vpcs');
+      if (Array.isArray(vpcsData)) {
+        logger.info(`📂 Carregando ${vpcsData.length} VPCs do storage...`);
+        for (const vpcData of vpcsData) {
+          const vpc = new VPC(vpcData.CidrBlock, vpcData.Tags, {
+            EnableDnsHostnames: vpcData.EnableDnsHostnames,
+            EnableDnsSupport: vpcData.EnableDnsSupport
+          });
+          vpc.VpcId = vpcData.VpcId;
+          vpc.State = vpcData.State;
+          this.vpcs.set(vpc.VpcId, vpc);
+        }
+      }
+
+      // Carregar Subnets
+      const subnetsData = this.store.read('subnets');
+      if (Array.isArray(subnetsData)) {
+        logger.info(`📂 Carregando ${subnetsData.length} Subnets do storage...`);
+        for (const subnetData of subnetsData) {
+          const subnet = new Subnet(
+            subnetData.VpcId,
+            subnetData.CidrBlock,
+            subnetData.AvailabilityZone,
+            subnetData.Tags,
+            { MapPublicIpOnLaunch: subnetData.MapPublicIpOnLaunch }
+          );
+          subnet.SubnetId = subnetData.SubnetId;
+          subnet.State = subnetData.State;
+          this.subnets.set(subnet.SubnetId, subnet);
+        }
+      }
+
+      // Carregar Internet Gateways
+      const igwsData = this.store.read('internet-gateways');
+      if (Array.isArray(igwsData)) {
+        logger.info(`📂 Carregando ${igwsData.length} Internet Gateways do storage...`);
+        for (const igwData of igwsData) {
+          const igw = new InternetGateway(igwData.Tags);
+          igw.InternetGatewayId = igwData.InternetGatewayId;
+          igw.Attachments = igwData.Attachments || [];
+          this.internetGateways.set(igw.InternetGatewayId, igw);
+        }
+      }
+
+      // Carregar Route Tables
+      const rtbsData = this.store.read('route-tables');
+      if (Array.isArray(rtbsData)) {
+        logger.info(`📂 Carregando ${rtbsData.length} Route Tables do storage...`);
+        for (const rtbData of rtbsData) {
+          const rtb = new RouteTable(rtbData.VpcId, rtbData.Tags);
+          rtb.RouteTableId = rtbData.RouteTableId;
+          rtb.State = rtbData.State || 'active';
+          rtb.CreatedAt = rtbData.CreatedAt || new Date().toISOString();
+          
+          // Desserializar Routes corretamente
+          const { Route } = require('./models/routeTable');
+          rtb.Routes = (rtbData.Routes || []).map(routeData => {
+            const route = new Route(
+              routeData.DestinationCidrBlock,
+              routeData.GatewayId || routeData.NatGatewayId || routeData.VpcEndpointId || routeData.InstanceId || routeData.NetworkInterfaceId || 'local',
+              routeData.GatewayId ? 'igw' : routeData.NatGatewayId ? 'nat' : routeData.VpcEndpointId ? 'vpce' : routeData.InstanceId ? 'instance' : routeData.NetworkInterfaceId ? 'eni' : 'local'
+            );
+            // Restaurar propriedades originais
+            route.State = routeData.State || 'active';
+            route.Origin = routeData.Origin || 'CreateRouteTable';
+            route.CreatedAt = routeData.CreatedAt || new Date().toISOString();
+            return route;
+          });
+          
+          // Desserializar Associations corretamente
+          const { RouteTableAssociation } = require('./models/routeTable');
+          rtb.Associations = (rtbData.Associations || []).map(assocData => {
+            const association = new RouteTableAssociation(assocData.SubnetId, assocData.RouteTableId, assocData.Main);
+            association.RouteTableAssociationId = assocData.RouteTableAssociationId || `rtbassoc-${uuidv4().substring(0, 8)}`;
+            association.CreatedAt = assocData.CreatedAt || new Date().toISOString();
+            return association;
+          });
+          
+          rtb.IsMain = rtbData.IsMain || false;
+          this.routeTables.set(rtb.RouteTableId, rtb);
+        }
+      }
+    } catch (error) {
+      logger.warn(`⚠️  Erro ao carregar dados persistidos: ${error.message}`);
+    }
+  }
+
+  /**
+   * Persiste estado atual em storage
+   */
+  persistData() {
+    try {
+      this.store.write('vpcs', Array.from(this.vpcs.values()).map(v => v.toJSON()));
+      this.store.write('subnets', Array.from(this.subnets.values()).map(s => s.toJSON()));
+      this.store.write('internet-gateways', Array.from(this.internetGateways.values()).map(igw => igw.toJSON()));
+      this.store.write('route-tables', Array.from(this.routeTables.values()).map(rt => rt.toJSON()));
+    } catch (error) {
+      logger.error(`Erro ao persistir dados VPC: ${error.message}`);
+    }
+  }
+
+  // ========== VPC Operations ==========
+
+  createVPC(cidrBlock, tags = [], config = {}) {
+    const vpc = new VPC(cidrBlock, tags, config);
+    this.vpcs.set(vpc.VpcId, vpc);
+
+    // Criar tabela de rotas padrão para VPC
+    const mainRouteTable = this.createRouteTable(vpc.VpcId, [], true);
+    
+    // ✅ Persistir mudanças
+    this.persistData();
+    
+    return vpc;
+  }
+
+  describeVPCs(filters = {}) {
+    let vpcs = Array.from(this.vpcs.values());
+
+    if (filters.vpcIds && Array.isArray(filters.vpcIds)) {
+      vpcs = vpcs.filter(v => filters.vpcIds.includes(v.VpcId));
+    }
+
+    if (filters.cidrBlock) {
+      vpcs = vpcs.filter(v => v.CidrBlock === filters.cidrBlock);
+    }
+
+    return vpcs;
+  }
+
+  getVPC(vpcId) {
+    const vpc = this.vpcs.get(vpcId);
+    if (!vpc) {
+      throw new Error(`VPC ${vpcId} not found`);
+    }
+    return vpc;
+  }
+
+  deleteVPC(vpcId) {
+    // Verificar dependências
+    const subnets = Array.from(this.subnets.values()).filter(s => s.VpcId === vpcId);
+    if (subnets.length > 0) {
+      throw new Error(`Cannot delete VPC ${vpcId}: VPC has subnets`);
+    }
+
+    const igws = Array.from(this.internetGateways.values()).filter(igw =>
+      igw.isAttachedTo(vpcId)
+    );
+    if (igws.length > 0) {
+      throw new Error(`Cannot delete VPC ${vpcId}: IGW still attached`);
+    }
+
+    // Deletar tabelas de rotas associadas
+    const rtbs = Array.from(this.routeTables.values()).filter(rt => rt.VpcId === vpcId);
+    for (const rtb of rtbs) {
+      this.routeTables.delete(rtb.RouteTableId);
+    }
+
+    this.vpcs.delete(vpcId);
+    
+    // ✅ Persistir mudanças
+    this.persistData();
+    
+    return true;
+  }
+
+  modifyVPCAttribute(vpcId, attribute, value) {
+    const vpc = this.getVPC(vpcId);
+
+    switch (attribute) {
+      case 'enableDnsHostnames':
+        vpc.EnableDnsHostnames = value;
+        break;
+      case 'enableDnsSupport':
+        vpc.EnableDnsSupport = value;
+        break;
+      default:
+        throw new Error(`Unknown VPC attribute: ${attribute}`);
+    }
+
+    // ✅ Persistir mudanças
+    this.persistData();
+
+    return vpc;
+  }
+
+  // ========== Subnet Operations ==========
+
+  createSubnet(vpcId, cidrBlock, availabilityZone, tags = [], config = {}) {
+    // Verificar se VPC existe
+    this.getVPC(vpcId);
+
+    // Verificar sobreposição de CIDR
+    const existingSubnets = Array.from(this.subnets.values()).filter(
+      s => s.VpcId === vpcId
+    );
+    if (this.hasCIDROverlap(cidrBlock, existingSubnets.map(s => s.CidrBlock))) {
+      throw new Error(`CIDR block ${cidrBlock} overlaps with existing subnets`);
+    }
+
+    const subnet = new Subnet(vpcId, cidrBlock, availabilityZone, tags, config);
+    this.subnets.set(subnet.SubnetId, subnet);
+    
+    // ✅ Persistir mudanças
+    this.persistData();
+    
+    return subnet;
+  }
+
+  describeSubnets(filters = {}) {
+    let subnets = Array.from(this.subnets.values());
+
+    if (filters.vpcIds && Array.isArray(filters.vpcIds)) {
+      subnets = subnets.filter(s => filters.vpcIds.includes(s.VpcId));
+    }
+
+    if (filters.subnetIds && Array.isArray(filters.subnetIds)) {
+      subnets = subnets.filter(s => filters.subnetIds.includes(s.SubnetId));
+    }
+
+    if (filters.cidrBlock) {
+      subnets = subnets.filter(s => s.CidrBlock === filters.cidrBlock);
+    }
+
+    return subnets;
+  }
+
+  getSubnet(subnetId) {
+    const subnet = this.subnets.get(subnetId);
+    if (!subnet) {
+      throw new Error(`Subnet ${subnetId} not found`);
+    }
+    return subnet;
+  }
+
+  deleteSubnet(subnetId) {
+    // Verificar dependências
+    const routeTableAssocs = Array.from(this.routeTables.values())
+      .flatMap(rt => rt.Associations)
+      .filter(a => a.SubnetId === subnetId);
+
+    if (routeTableAssocs.length > 0) {
+      throw new Error(`Subnet ${subnetId} has associated route tables`);
+    }
+
+    this.subnets.delete(subnetId);
+    
+    // ✅ Persistir mudanças
+    this.persistData();
+    
+    return true;
+  }
+
+  // ========== Route Table Operations ==========
+
+  createRouteTable(vpcId, tags = [], isMain = false) {
+    // Verificar se VPC existe
+    this.getVPC(vpcId);
+
+    const routeTable = new RouteTable(vpcId, tags, isMain);
+    this.routeTables.set(routeTable.RouteTableId, routeTable);
+    
+    // ✅ Persistir mudanças (apenas se não for main table)
+    if (!isMain) {
+      this.persistData();
+    }
+    
+    return routeTable;
+  }
+
+  describeRouteTables(filters = {}) {
+    let routeTables = Array.from(this.routeTables.values());
+
+    if (filters.vpcIds && Array.isArray(filters.vpcIds)) {
+      routeTables = routeTables.filter(rt => filters.vpcIds.includes(rt.VpcId));
+    }
+
+    if (filters.routeTableIds && Array.isArray(filters.routeTableIds)) {
+      routeTables = routeTables.filter(rt => filters.routeTableIds.includes(rt.RouteTableId));
+    }
+
+    return routeTables;
+  }
+
+  getRouteTable(routeTableId) {
+    const rt = this.routeTables.get(routeTableId);
+    if (!rt) {
+      throw new Error(`Route Table ${routeTableId} not found`);
+    }
+    return rt;
+  }
+
+  deleteRouteTable(routeTableId) {
+    const rt = this.getRouteTable(routeTableId);
+
+    if (rt.IsMain) {
+      throw new Error(`Cannot delete main route table ${routeTableId}`);
+    }
+
+    if (rt.Associations.length > 0) {
+      throw new Error(`Cannot delete route table with associations`);
+    }
+
+    this.routeTables.delete(routeTableId);
+    
+    // ✅ Persistir mudanças
+    this.persistData();
+    
+    return true;
+  }
+
+  addRoute(routeTableId, destinationCidrBlock, target, targetType = 'igw') {
+    const rt = this.getRouteTable(routeTableId);
+    const route = rt.addRoute(destinationCidrBlock, target, targetType);
+    
+    // ✅ Persistir mudanças
+    this.persistData();
+    
+    return route;
+  }
+
+  removeRoute(routeTableId, destinationCidrBlock) {
+    const rt = this.getRouteTable(routeTableId);
+    const route = rt.removeRoute(destinationCidrBlock);
+    return route;
+  }
+
+  associateRouteTable(routeTableId, subnetId) {
+    const rt = this.getRouteTable(routeTableId);
+    this.getSubnet(subnetId);
+
+    const association = rt.addAssociation(subnetId);
+    
+    // ✅ Persistir mudanças
+    this.persistData();
+    
+    return association;
+  }
+
+  disassociateRouteTable(routeTableId, subnetId) {
+    const rt = this.getRouteTable(routeTableId);
+    const association = rt.removeAssociation(subnetId);
+    
+    // ✅ Persistir mudanças
+    this.persistData();
+    
+    return association;
+  }
+
+  // ========== Internet Gateway Operations ==========
+
+  createInternetGateway(tags = []) {
+    const igw = new InternetGateway(tags);
+    this.internetGateways.set(igw.InternetGatewayId, igw);
+    
+    // ✅ Persistir mudanças
+    this.persistData();
+    
+    return igw;
+  }
+
+  describeInternetGateways(filters = {}) {
+    let igws = Array.from(this.internetGateways.values());
+
+    if (filters.internetGatewayIds && Array.isArray(filters.internetGatewayIds)) {
+      igws = igws.filter(igw => filters.internetGatewayIds.includes(igw.InternetGatewayId));
+    }
+
+    return igws;
+  }
+
+  getInternetGateway(internetGatewayId) {
+    const igw = this.internetGateways.get(internetGatewayId);
+    if (!igw) {
+      throw new Error(`Internet Gateway ${internetGatewayId} not found`);
+    }
+    return igw;
+  }
+
+  attachInternetGateway(internetGatewayId, vpcId) {
+    const igw = this.getInternetGateway(internetGatewayId);
+    this.getVPC(vpcId);
+
+    const attachment = igw.attach(vpcId);
+    
+    // ✅ Persistir mudanças
+    this.persistData();
+    
+    return attachment;
+  }
+
+  detachInternetGateway(internetGatewayId, vpcId) {
+    const igw = this.getInternetGateway(internetGatewayId);
+    const attachment = igw.detach(vpcId);
+    
+    // ✅ Persistir mudanças
+    this.persistData();
+    
+    return attachment;
+  }
+
+  deleteInternetGateway(internetGatewayId) {
+    const igw = this.getInternetGateway(internetGatewayId);
+
+    if (igw.Attachments.length > 0) {
+      throw new Error(`Cannot delete Internet Gateway with attachments`);
+    }
+
+    this.internetGateways.delete(internetGatewayId);
+    
+    // ✅ Persistir mudanças
+    this.persistData();
+    
+    return true;
+  }
+
+  // ========== VPC Endpoint Operations ==========
+
+  createVPCEndpoint(vpcId, serviceName, config = {}) {
+    this.getVPC(vpcId);
+
+    const endpoint = new VPCEndpoint(vpcId, serviceName, config);
+    this.vpcEndpoints.set(endpoint.VpcEndpointId, endpoint);
+    return endpoint;
+  }
+
+  describeVPCEndpoints(filters = {}) {
+    let endpoints = Array.from(this.vpcEndpoints.values());
+
+    if (filters.vpcIds && Array.isArray(filters.vpcIds)) {
+      endpoints = endpoints.filter(e => filters.vpcIds.includes(e.VpcId));
+    }
+
+    if (filters.vpcEndpointIds && Array.isArray(filters.vpcEndpointIds)) {
+      endpoints = endpoints.filter(e => filters.vpcEndpointIds.includes(e.VpcEndpointId));
+    }
+
+    if (filters.serviceName) {
+      endpoints = endpoints.filter(e => e.ServiceName === filters.serviceName);
+    }
+
+    return endpoints;
+  }
+
+  getVPCEndpoint(vpcEndpointId) {
+    const endpoint = this.vpcEndpoints.get(vpcEndpointId);
+    if (!endpoint) {
+      throw new Error(`VPC Endpoint ${vpcEndpointId} not found`);
+    }
+    return endpoint;
+  }
+
+  deleteVPCEndpoint(vpcEndpointId) {
+    this.vpcEndpoints.delete(vpcEndpointId);
+    return true;
+  }
+
+  modifyVPCEndpoint(vpcEndpointId, changes) {
+    const endpoint = this.getVPCEndpoint(vpcEndpointId);
+
+    if (changes.RouteTableIds) {
+      endpoint.RouteTableIds = changes.RouteTableIds;
+    }
+
+    if (changes.SubnetIds) {
+      endpoint.SubnetIds = changes.SubnetIds;
+    }
+
+    if (changes.PolicyDocument) {
+      endpoint.PolicyDocument = changes.PolicyDocument;
+    }
+
+    return endpoint;
+  }
+
+  // ========== VPC Gateway Operations (NAT, VPN, etc) ==========
+
+  createNATGateway(subnetId, allocationId, config = {}) {
+    this.getSubnet(subnetId);
+
+    const natGw = new NATGateway(subnetId, allocationId, config);
+    this.natGateways.set(natGw.NatGatewayId, natGw);
+    return natGw;
+  }
+
+  describeNATGateways(filters = {}) {
+    let gateways = Array.from(this.natGateways.values());
+
+    if (filters.natGatewayIds && Array.isArray(filters.natGatewayIds)) {
+      gateways = gateways.filter(ng => filters.natGatewayIds.includes(ng.NatGatewayId));
+    }
+
+    if (filters.subnetIds && Array.isArray(filters.subnetIds)) {
+      gateways = gateways.filter(ng => filters.subnetIds.includes(ng.SubnetId));
+    }
+
+    return gateways;
+  }
+
+  deleteNATGateway(natGatewayId) {
+    this.natGateways.delete(natGatewayId);
+    return true;
+  }
+
+  // Utility methods
+
+  hasCIDROverlap(newCidr, existingCidrs) {
+    const parseNetworkCIDR = (cidr) => {
+      const [ip, prefix] = cidr.split('/');
+      const parts = ip.split('.').map(Number);
+      const ipNum = (parts[0] << 24) + (parts[1] << 16) + (parts[2] << 8) + parts[3];
+      const prefixNum = parseInt(prefix) || 32;
+      const mask = (0xffffffff << (32 - prefixNum)) >>> 0;
+      return { ipNum, mask };
+    };
+
+    const { ipNum: newIp, mask: newMask } = parseNetworkCIDR(newCidr);
+
+    for (const existingCidr of existingCidrs) {
+      const { ipNum: existingIp, mask: existingMask } = parseNetworkCIDR(existingCidr);
+
+      if ((newIp & newMask) === (existingIp & newMask)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  getAllResources() {
+    return {
+      vpcs: Array.from(this.vpcs.values()),
+      subnets: Array.from(this.subnets.values()),
+      routeTables: Array.from(this.routeTables.values()),
+      internetGateways: Array.from(this.internetGateways.values()),
+      vpcEndpoints: Array.from(this.vpcEndpoints.values()),
+      natGateways: Array.from(this.natGateways.values())
+    };
+  }
+}
+
+module.exports = VPCSimulator;