@gugananuvem/aws-local-simulator 1.0.34 → 1.0.39

package/src/services/vpc/ec2ResponseFormatter.js

@@ -0,0 +1,431 @@
+/**
+ * EC2ResponseFormatter
+ * Converte respostas do VPC Simulator para formato XML compatível com AWS CLI
+ */
+
+const xml = require('xmlbuilder');
+
+class EC2ResponseFormatter {
+  /**
+   * Formata resposta DescribeVpcs para XML
+   */
+  static formatDescribeVpcsResponse(vpcs, requestId = 'vpc-request-1') {
+    const xmlObj = {
+      DescribeVpcsResponse: {
+        '@xmlns': 'http://ec2.amazonaws.com/doc/2016-11-15/',
+        requestId: requestId,
+        vpcSet: {
+          item: vpcs.map(vpc => ({
+            vpcId: vpc.VpcId,
+            state: vpc.State,
+            cidrBlock: vpc.CidrBlock,
+            dhcpOptionsId: vpc.DhcpOptionsId || 'dopt-default',
+            tagSet: this._formatTags(vpc.Tags),
+            isDefault: vpc.IsDefault || false,
+            cidrBlockAssociationSet: {
+              item: {
+                cidrBlock: vpc.CidrBlock,
+                cidrBlockState: {
+                  state: 'associated'
+                }
+              }
+            }
+          }))
+        }
+      }
+    };
+
+    return this._buildXml(xmlObj);
+  }
+
+  /**
+   * Formata resposta CreateVpc para XML
+   */
+  static formatCreateVpcResponse(vpc, requestId = 'vpc-request-1') {
+    const xmlObj = {
+      CreateVpcResponse: {
+        '@xmlns': 'http://ec2.amazonaws.com/doc/2016-11-15/',
+        requestId: requestId,
+        vpc: {
+          vpcId: vpc.VpcId,
+          state: vpc.State,
+          cidrBlock: vpc.CidrBlock,
+          dhcpOptionsId: vpc.DhcpOptionsId || 'dopt-default',
+          tagSet: this._formatTags(vpc.Tags),
+          isDefault: vpc.IsDefault || false,
+          cidrBlockAssociationSet: {
+            item: {
+              cidrBlock: vpc.CidrBlock,
+              cidrBlockState: {
+                state: 'associated'
+              }
+            }
+          }
+        }
+      }
+    };
+
+    return this._buildXml(xmlObj);
+  }
+
+  /**
+   * Formata resposta DeleteVpc para XML
+   */
+  static formatDeleteVpcResponse(requestId = 'vpc-request-1') {
+    const xmlObj = {
+      DeleteVpcResponse: {
+        '@xmlns': 'http://ec2.amazonaws.com/doc/2016-11-15/',
+        requestId: requestId,
+        'return': true
+      }
+    };
+
+    return this._buildXml(xmlObj);
+  }
+
+  /**
+   * Formata resposta DescribeSubnets para XML
+   */
+  static formatDescribeSubnetsResponse(subnets, requestId = 'vpc-request-1') {
+    const xmlObj = {
+      DescribeSubnetsResponse: {
+        '@xmlns': 'http://ec2.amazonaws.com/doc/2016-11-15/',
+        requestId: requestId,
+        subnetSet: {
+          item: subnets.map(subnet => ({
+            subnetId: subnet.SubnetId,
+            state: subnet.State,
+            vpcId: subnet.VpcId,
+            cidrBlock: subnet.CidrBlock,
+            ipv6CidrBlockAssociationSet: {
+              item: []
+            },
+            availabilityZone: subnet.AvailabilityZone,
+            availabilityZoneId: this._getAZId(subnet.AvailabilityZone),
+            availableIpAddressCount: subnet.AvailableIpAddressCount || 251,
+            defaultForAz: false,
+            mapPublicIpOnLaunch: subnet.MapPublicIpOnLaunch || false,
+            mapCustomerOwnedIpOnLaunch: false,
+            tagSet: this._formatTags(subnet.Tags)
+          }))
+        }
+      }
+    };
+
+    return this._buildXml(xmlObj);
+  }
+
+  /**
+   * Formata resposta CreateSubnet para XML
+   */
+  static formatCreateSubnetResponse(subnet, requestId = 'vpc-request-1') {
+    const xmlObj = {
+      CreateSubnetResponse: {
+        '@xmlns': 'http://ec2.amazonaws.com/doc/2016-11-15/',
+        requestId: requestId,
+        subnet: {
+          subnetId: subnet.SubnetId,
+          state: subnet.State,
+          vpcId: subnet.VpcId,
+          cidrBlock: subnet.CidrBlock,
+          ipv6CidrBlockAssociationSet: {
+            item: []
+          },
+          availabilityZone: subnet.AvailabilityZone,
+          availabilityZoneId: this._getAZId(subnet.AvailabilityZone),
+          availableIpAddressCount: subnet.AvailableIpAddressCount || 251,
+          defaultForAz: false,
+          mapPublicIpOnLaunch: subnet.MapPublicIpOnLaunch || false,
+          mapCustomerOwnedIpOnLaunch: false,
+          tagSet: this._formatTags(subnet.Tags)
+        }
+      }
+    };
+
+    return this._buildXml(xmlObj);
+  }
+
+  /**
+   * Formata resposta DeleteSubnet para XML
+   */
+  static formatDeleteSubnetResponse(requestId = 'vpc-request-1') {
+    const xmlObj = {
+      DeleteSubnetResponse: {
+        '@xmlns': 'http://ec2.amazonaws.com/doc/2016-11-15/',
+        requestId: requestId,
+        'return': true
+      }
+    };
+
+    return this._buildXml(xmlObj);
+  }
+
+  /**
+   * Formata resposta DescribeInternetGateways para XML
+   */
+  static formatDescribeIgwResponse(igws, requestId = 'vpc-request-1') {
+    const xmlObj = {
+      DescribeInternetGatewaysResponse: {
+        '@xmlns': 'http://ec2.amazonaws.com/doc/2016-11-15/',
+        requestId: requestId,
+        internetGatewaySet: {
+          item: igws.map(igw => ({
+            internetGatewayId: igw.InternetGatewayId,
+            attachmentSet: {
+              item: igw.Attachments.map(att => ({
+                vpcId: att.VpcId,
+                state: att.State
+              }))
+            },
+            tagSet: this._formatTags(igw.Tags)
+          }))
+        }
+      }
+    };
+
+    return this._buildXml(xmlObj);
+  }
+
+  /**
+   * Formata resposta CreateInternetGateway para XML
+   */
+  static formatCreateIgwResponse(igw, requestId = 'vpc-request-1') {
+    const xmlObj = {
+      CreateInternetGatewayResponse: {
+        '@xmlns': 'http://ec2.amazonaws.com/doc/2016-11-15/',
+        requestId: requestId,
+        internetGateway: {
+          internetGatewayId: igw.InternetGatewayId,
+          attachmentSet: {
+            item: igw.Attachments.map(att => ({
+              vpcId: att.VpcId,
+              state: att.State
+            }))
+          },
+          tagSet: this._formatTags(igw.Tags)
+        }
+      }
+    };
+
+    return this._buildXml(xmlObj);
+  }
+
+  /**
+   * Formata resposta AttachInternetGateway para XML
+   */
+  static formatAttachIgwResponse(requestId = 'vpc-request-1') {
+    const xmlObj = {
+      AttachInternetGatewayResponse: {
+        '@xmlns': 'http://ec2.amazonaws.com/doc/2016-11-15/',
+        requestId: requestId,
+        'return': true
+      }
+    };
+
+    return this._buildXml(xmlObj);
+  }
+
+  /**
+   * Formata resposta DetachInternetGateway para XML
+   */
+  static formatDetachIgwResponse(requestId = 'vpc-request-1') {
+    const xmlObj = {
+      DetachInternetGatewayResponse: {
+        '@xmlns': 'http://ec2.amazonaws.com/doc/2016-11-15/',
+        requestId: requestId,
+        'return': true
+      }
+    };
+
+    return this._buildXml(xmlObj);
+  }
+
+  /**
+   * Formata resposta DeleteInternetGateway para XML
+   */
+  static formatDeleteIgwResponse(requestId = 'vpc-request-1') {
+    const xmlObj = {
+      DeleteInternetGatewayResponse: {
+        '@xmlns': 'http://ec2.amazonaws.com/doc/2016-11-15/',
+        requestId: requestId,
+        'return': true
+      }
+    };
+
+    return this._buildXml(xmlObj);
+  }
+
+  /**
+   * Formata resposta DescribeRouteTables para XML
+   */
+  static formatDescribeRouteTablesResponse(routeTables, requestId = 'vpc-request-1') {
+    const xmlObj = {
+      DescribeRouteTablesResponse: {
+        '@xmlns': 'http://ec2.amazonaws.com/doc/2016-11-15/',
+        requestId: requestId,
+        routeTableSet: {
+          item: routeTables.map(rt => ({
+            routeTableId: rt.RouteTableId,
+            vpcId: rt.VpcId,
+            routeSet: {
+              item: rt.Routes.map(route => ({
+                destinationCidrBlock: route.DestinationCidrBlock,
+                target: route.Target,
+                state: route.State || 'active',
+                origin: route.Origin || 'CreateRouteTable'
+              }))
+            },
+            associationSet: {
+              item: rt.Associations.map(assoc => ({
+                routeTableAssociationId: assoc.RouteTableAssociationId,
+                routeTableId: assoc.RouteTableId,
+                subnetId: assoc.SubnetId || '',
+                main: assoc.Main || false,
+                associationState: {
+                  state: assoc.State || 'associated'
+                }
+              }))
+            },
+            tagSet: this._formatTags(rt.Tags),
+            propagatingVgwSet: []
+          }))
+        }
+      }
+    };
+
+    return this._buildXml(xmlObj);
+  }
+
+  /**
+   * Formata resposta CreateRouteTable para XML
+   */
+  static formatCreateRouteTableResponse(routeTable, requestId = 'vpc-request-1') {
+    const xmlObj = {
+      CreateRouteTableResponse: {
+        '@xmlns': 'http://ec2.amazonaws.com/doc/2016-11-15/',
+        requestId: requestId,
+        routeTable: {
+          routeTableId: routeTable.RouteTableId,
+          vpcId: routeTable.VpcId,
+          routeSet: {
+            item: routeTable.Routes.map(route => ({
+              destinationCidrBlock: route.DestinationCidrBlock,
+              target: route.Target,
+              state: route.State || 'active',
+              origin: route.Origin || 'CreateRouteTable'
+            }))
+          },
+          associationSet: {
+            item: routeTable.Associations.map(assoc => ({
+              routeTableAssociationId: assoc.RouteTableAssociationId,
+              routeTableId: assoc.RouteTableId,
+              subnetId: assoc.SubnetId || '',
+              main: assoc.Main || false,
+              associationState: {
+                state: assoc.State || 'associated'
+              }
+            }))
+          },
+          tagSet: this._formatTags(routeTable.Tags),
+          propagatingVgwSet: []
+        }
+      }
+    };
+
+    return this._buildXml(xmlObj);
+  }
+
+  /**
+   * Formata resposta DeleteRouteTable para XML
+   */
+  static formatDeleteRouteTableResponse(requestId = 'vpc-request-1') {
+    const xmlObj = {
+      DeleteRouteTableResponse: {
+        '@xmlns': 'http://ec2.amazonaws.com/doc/2016-11-15/',
+        requestId: requestId,
+        'return': true
+      }
+    };
+
+    return this._buildXml(xmlObj);
+  }
+
+  /**
+   * Formata resposta CreateRoute para XML
+   */
+  static formatCreateRouteResponse(requestId = 'vpc-request-1') {
+    const xmlObj = {
+      CreateRouteResponse: {
+        '@xmlns': 'http://ec2.amazonaws.com/doc/2016-11-15/',
+        requestId: requestId,
+        'return': true
+      }
+    };
+
+    return this._buildXml(xmlObj);
+  }
+
+  /**
+   * Formata erro para XML
+   */
+  static formatErrorResponse(code, message, requestId = 'vpc-request-1') {
+    const xmlObj = {
+      Response: {
+        Errors: {
+          Error: {
+            Code: code,
+            Message: message
+          }
+        },
+        RequestId: requestId
+      }
+    };
+
+    return this._buildXml(xmlObj);
+  }
+
+  /**
+   * Helper: formata tags em XML
+   */
+  static _formatTags(tags = []) {
+    if (!tags || tags.length === 0) {
+      return { item: [] };
+    }
+
+    return {
+      item: tags.map(tag => ({
+        key: tag.Key || tag.key,
+        value: tag.Value || tag.value
+      }))
+    };
+  }
+
+  /**
+   * Helper: converte zona de disponibilidade para AZ ID
+   */
+  static _getAZId(availabilityZone) {
+    // Exemplo: us-east-1a -> use1-az1
+    const azMap = {
+      'us-east-1a': 'use1-az1',
+      'us-east-1b': 'use1-az2',
+      'us-east-1c': 'use1-az4',
+      'us-west-1a': 'usw1-az1',
+      'us-west-1b': 'usw1-az2',
+      'eu-west-1a': 'euw1-az1',
+      'eu-west-1b': 'euw1-az2',
+      'eu-west-1c': 'euw1-az3'
+    };
+
+    return azMap[availabilityZone] || 'use1-az1';
+  }
+
+  /**
+   * Helper: constrói XML a partir de objeto
+   */
+  static _buildXml(obj) {
+    const root = xml.create(obj);
+    return '<?xml version="1.0" encoding="UTF-8"?>\n' + root.toString();
+  }
+}
+
+module.exports = EC2ResponseFormatter;

package/src/services/vpc/index.js

@@ -0,0 +1,90 @@
+/**
+ * VPC Service - Ponto de entrada
+ * Exporta o serviço principal e seus componentes
+ */
+
+const VPCServer = require('./server');
+const VPCSimulator = require('./simulator');
+
+class VPCService {
+  constructor(config) {
+    this.config = config;
+    this.name = 'vpc';
+    this.port = config.ports.vpc || 4014;
+    this.server = null;
+    this.simulator = null;
+    this.isRunning = false;
+  }
+
+  async initialize() {
+    const logger = require('../../utils/logger');
+    logger.debug(`Inicializando VPC Service na porta ${this.port}...`);
+
+    this.simulator = new VPCSimulator(this.config.vpc || {});
+    await this.simulator.initialize();
+
+    this.server = new VPCServer(this.port, this.config);
+    this.server.simulator = this.simulator;
+
+    await this.server.initialize();
+
+    logger.debug('VPC Service inicializado');
+  }
+
+  injectDependencies(server) {
+    // Aqui você pode injetar dependências de outros serviços se necessário
+    // Por exemplo, para integração com CloudFormation
+  }
+
+  async start() {
+    const logger = require('../../utils/logger');
+
+    if (this.isRunning) {
+      logger.warn('VPC Service já está em execução');
+      return;
+    }
+
+    try {
+      await this.server.start();
+      this.isRunning = true;
+      logger.info('VPC Service iniciado com sucesso');
+    } catch (error) {
+      logger.error(`Erro ao iniciar VPC Service: ${error.message}`);
+      throw error;
+    }
+  }
+
+  async stop() {
+    const logger = require('../../utils/logger');
+
+    if (!this.isRunning) {
+      logger.warn('VPC Service não está em execução');
+      return;
+    }
+
+    try {
+      await this.server.stop();
+      this.isRunning = false;
+      logger.info('VPC Service parado com sucesso');
+    } catch (error) {
+      logger.error(`Erro ao parar VPC Service: ${error.message}`);
+      throw error;
+    }
+  }
+
+  getSimulator() {
+    return this.simulator;
+  }
+
+  getStatus() {
+    return {
+      name: this.name,
+      running: this.isRunning,
+      port: this.port,
+      endpoint: `http://localhost:${this.port}`,
+      resources: this.simulator.getAllResources()
+    };
+  }
+}
+
+module.exports = VPCService;

package/src/services/vpc/models/internetGateway.js

@@ -0,0 +1,71 @@
+/**
+ * Internet Gateway Model
+ */
+
+const { v4: uuidv4 } = require('uuid');
+
+class InternetGatewayAttachment {
+  constructor(vpcId) {
+    this.VpcId = vpcId;
+    this.State = 'available';
+    this.CreatedAt = new Date().toISOString();
+  }
+
+  toJSON() {
+    return {
+      VpcId: this.VpcId,
+      State: this.State
+    };
+  }
+}
+
+class InternetGateway {
+  constructor(tags = []) {
+    this.InternetGatewayId = `igw-${uuidv4().substring(0, 8)}`;
+    this.Attachments = [];
+    this.Tags = tags;
+    this.State = 'available';
+    this.OwnerId = '123456789012';
+    this.CreatedAt = new Date().toISOString();
+  }
+
+  attach(vpcId) {
+    // Verificar se já está anexado a esta VPC
+    const exists = this.Attachments.some(a => a.VpcId === vpcId);
+    if (exists) {
+      throw new Error(`IGW already attached to VPC ${vpcId}`);
+    }
+
+    const attachment = new InternetGatewayAttachment(vpcId);
+    this.Attachments.push(attachment);
+    return attachment;
+  }
+
+  detach(vpcId) {
+    const index = this.Attachments.findIndex(a => a.VpcId === vpcId);
+    if (index === -1) {
+      throw new Error(`IGW not attached to VPC ${vpcId}`);
+    }
+
+    const attachment = this.Attachments[index];
+    this.Attachments.splice(index, 1);
+    return attachment;
+  }
+
+  isAttachedTo(vpcId) {
+    return this.Attachments.some(a => a.VpcId === vpcId);
+  }
+
+  toJSON() {
+    return {
+      InternetGatewayId: this.InternetGatewayId,
+      Attachments: this.Attachments.map(a => a.toJSON()),
+      Tags: this.Tags,
+      State: this.State,
+      OwnerId: this.OwnerId,
+      CreatedAt: this.CreatedAt
+    };
+  }
+}
+
+module.exports = { InternetGateway, InternetGatewayAttachment };