@gugananuvem/aws-local-simulator 1.0.34 → 1.0.39

package/src/services/ec2/index.js

@@ -0,0 +1,101 @@
+/**
+ * EC2 Service - Ponto de entrada
+ */
+
+const EC2Server = require('./server');
+const EC2Simulator = require('./simulator');
+
+class EC2Service {
+  constructor(config) {
+    this.config = config;
+    this.name = 'ec2';
+    this.port = config.ports.ec2 || 4020;
+    this.server = null;
+    this.simulator = null;
+    this.isRunning = false;
+  }
+
+  async initialize() {
+    const logger = require('../../utils/logger');
+    logger.debug(`Inicializando EC2 Service na porta ${this.port}...`);
+
+    this.simulator = new EC2Simulator(this.config.ec2 || {});
+    await this.simulator.initialize();
+
+    this.server = new EC2Server(this.port, this.config);
+    this.server.simulator = this.simulator;
+
+    await this.server.initialize();
+
+    logger.debug('EC2 Service inicializado');
+  }
+
+  injectDependencies(server) {
+    // Aqui você pode injetar dependências de outros serviços se necessário
+    // Por exemplo, integração com VPC
+  }
+
+  async start() {
+    const logger = require('../../utils/logger');
+
+    if (this.isRunning) {
+      logger.warn('EC2 Service já está em execução');
+      return;
+    }
+
+    try {
+      await this.server.start();
+      this.isRunning = true;
+      logger.info('EC2 Service iniciado com sucesso');
+    } catch (error) {
+      logger.error(`Erro ao iniciar EC2 Service: ${error.message}`);
+      throw error;
+    }
+  }
+
+  async stop() {
+    const logger = require('../../utils/logger');
+
+    if (!this.isRunning) {
+      logger.warn('EC2 Service não está em execução');
+      return;
+    }
+
+    try {
+      // Parar todos os servidores web das instâncias
+      for (const [instanceId, server] of this.simulator.instanceServers) {
+        await server.stop();
+      }
+
+      await this.server.stop();
+      this.isRunning = false;
+      logger.info('EC2 Service parado com sucesso');
+    } catch (error) {
+      logger.error(`Erro ao parar EC2 Service: ${error.message}`);
+      throw error;
+    }
+  }
+
+  getSimulator() {
+    return this.simulator;
+  }
+
+  getStatus() {
+    const instances = this.simulator.getAllResources();
+    return {
+      name: this.name,
+      running: this.isRunning,
+      port: this.port,
+      endpoint: `http://localhost:${this.port}`,
+      resources: {
+        instancesCount: instances.instances.length,
+        runningCount: instances.instances.filter(i => i.isRunning()).length,
+        amisCount: instances.amis.length,
+        securityGroupsCount: instances.securityGroups.length,
+        networkInterfacesCount: instances.networkInterfaces.length
+      }
+    };
+  }
+}
+
+module.exports = EC2Service;

package/src/services/ec2/instanceServer.js

@@ -0,0 +1,311 @@
+/**
+ * Instance Server - Mini HTTP Server para cada EC2 Instance
+ * Serve um site HTML/Angular, página padrão, ou atua como proxy para URL externa
+ */
+
+const express = require('express');
+const path = require('path');
+const fs = require('fs');
+const axios = require('axios');
+const { createProxyMiddleware } = require('http-proxy-middleware');
+const logger = require('../../utils/logger');
+
+class InstanceServer {
+  constructor(instance, websiteDir = null) {
+    this.instance = instance;
+    this.websiteDir = websiteDir;
+    this.app = express();
+    this.server = null;
+    this.setupApp();
+  }
+
+  setupApp() {
+    this.app.use(express.json());
+
+    // Middleware de log
+    this.app.use((req, res, next) => {
+      logger.debug(`[EC2:${this.instance.InstanceId}] ${req.method} ${req.path}`);
+      next();
+    });
+
+    // Health check
+    this.app.get('/__health', (req, res) => {
+      res.json({
+        status: 'ok',
+        instanceId: this.instance.InstanceId,
+        state: this.instance.State,
+        isProxy: !!this.instance.ProxyUrl
+      });
+    });
+
+    // Metadata (similar ao AWS metadata service)
+    this.app.get('/__metadata', (req, res) => {
+      res.json({
+        instanceId: this.instance.InstanceId,
+        instanceType: this.instance.InstanceType,
+        privateIp: this.instance.PrivateIpAddress,
+        publicIp: this.instance.PublicIpAddress,
+        vpcId: this.instance.VpcId,
+        subnetId: this.instance.SubnetId,
+        launchTime: this.instance.LaunchTime,
+        imageId: this.instance.ImageId,
+        proxyUrl: this.instance.ProxyUrl || null
+      });
+    });
+
+    // Se ProxyUrl configurada, usar http-proxy-middleware
+    if (this.instance.ProxyUrl) {
+      logger.info(`[EC2:${this.instance.InstanceId}] 🔗 Proxy configurado para: ${this.instance.ProxyUrl}`);
+      
+      this.app.use('/', createProxyMiddleware({
+        target: this.instance.ProxyUrl,
+        changeOrigin: true,
+        pathRewrite: {},
+        ws: true, // WebSocket suport
+        logLevel: 'warn',
+        onError: (err, req, res) => {
+          logger.error(`[EC2:${this.instance.InstanceId}] Proxy error: ${err.message}`);
+          res.status(503).json({
+            error: 'Proxy service unavailable',
+            target: this.instance.ProxyUrl,
+            message: err.message
+          });
+        }
+      }));
+    } else if (this.websiteDir && fs.existsSync(this.websiteDir)) {
+      // Se website dir configurado, servir arquivos estáticos
+      logger.info(`[EC2:${this.instance.InstanceId}] Servindo website de: ${this.websiteDir}`);
+      this.app.use(express.static(this.websiteDir));
+
+      // SPA fallback (para Angular, React, Vue)
+      this.app.get(/^(?!__).+/, (req, res, next) => {
+        const indexPath = path.join(this.websiteDir, 'index.html');
+        if (fs.existsSync(indexPath)) {
+          res.sendFile(indexPath);
+        } else {
+          next();
+        }
+      });
+    }
+
+    // Página padrão (se não houver website nem proxy)
+    if (!this.instance.ProxyUrl) {
+      this.app.get('/', (req, res) => {
+        const html = this.getDefaultPage();
+        res.set('Content-Type', 'text/html; charset=utf-8').send(html);
+      });
+    }
+
+    // 404
+    this.app.use((req, res) => {
+      res.status(404).json({
+        error: 'Not Found',
+        instanceId: this.instance.InstanceId,
+        path: req.path
+      });
+    });
+  }
+
+  getDefaultPage() {
+    const proxyInfo = this.instance.ProxyUrl ? `
+      <div class="info-item proxy-item">
+        <div class="info-label">🔗 Proxy URL</div>
+        <div class="info-value">${this.instance.ProxyUrl}</div>
+      </div>
+    ` : '';
+
+    return `
+<!DOCTYPE html>
+<html lang="pt-BR">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>EC2 Instance - ${this.instance.InstanceId}</title>
+  <style>
+    * {
+      margin: 0;
+      padding: 0;
+      box-sizing: border-box;
+    }
+    body {
+      font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+      min-height: 100vh;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      padding: 20px;
+    }
+    .container {
+      background: white;
+      border-radius: 10px;
+      box-shadow: 0 10px 40px rgba(0, 0, 0, 0.3);
+      padding: 40px;
+      max-width: 600px;
+      width: 100%;
+    }
+    .header {
+      text-align: center;
+      margin-bottom: 30px;
+      border-bottom: 3px solid #667eea;
+      padding-bottom: 20px;
+    }
+    .header h1 {
+      color: #333;
+      font-size: 28px;
+      margin-bottom: 10px;
+    }
+    .status {
+      display: inline-block;
+      padding: 8px 16px;
+      border-radius: 20px;
+      font-weight: bold;
+      font-size: 14px;
+      ${this.instance.isRunning() ? 'background: #4caf50; color: white;' : 'background: #ff9800; color: white;'}
+    }
+    .info-grid {
+      display: grid;
+      grid-template-columns: 1fr 1fr;
+      gap: 20px;
+      margin-bottom: 20px;
+    }
+    .info-item {
+      background: #f5f5f5;
+      padding: 15px;
+      border-radius: 8px;
+      border-left: 4px solid #667eea;
+    }
+    .info-item.proxy-item {
+      grid-column: 1 / -1;
+      border-left-color: #2196f3;
+      background: #e3f2fd;
+    }
+    .info-label {
+      color: #666;
+      font-size: 12px;
+      font-weight: bold;
+      text-transform: uppercase;
+      margin-bottom: 5px;
+    }
+    .info-value {
+      color: #333;
+      font-size: 16px;
+      font-weight: 500;
+      word-break: break-all;
+    }
+    .metadata-link {
+      text-align: center;
+      margin-top: 20px;
+      padding-top: 20px;
+      border-top: 1px solid #eee;
+    }
+    .metadata-link a {
+      color: #667eea;
+      text-decoration: none;
+      font-size: 14px;
+    }
+    .metadata-link a:hover {
+      text-decoration: underline;
+    }
+    .footer {
+      text-align: center;
+      margin-top: 20px;
+      color: #999;
+      font-size: 12px;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="header">
+      <h1>🖥️ AWS EC2 Instance</h1>
+      <div class="status">${this.instance.State.toUpperCase()}</div>
+    </div>
+    
+    <div class="info-grid">
+      <div class="info-item">
+        <div class="info-label">Instance ID</div>
+        <div class="info-value">${this.instance.InstanceId}</div>
+      </div>
+      
+      <div class="info-item">
+        <div class="info-label">Instance Type</div>
+        <div class="info-value">${this.instance.InstanceType}</div>
+      </div>
+      
+      <div class="info-item">
+        <div class="info-label">Public IP</div>
+        <div class="info-value">${this.instance.PublicIpAddress}</div>
+      </div>
+      
+      <div class="info-item">
+        <div class="info-label">Private IP</div>
+        <div class="info-value">${this.instance.PrivateIpAddress}</div>
+      </div>
+      
+      <div class="info-item">
+        <div class="info-label">VPC ID</div>
+        <div class="info-value">${this.instance.VpcId || 'N/A'}</div>
+      </div>
+      
+      <div class="info-item">
+        <div class="info-label">Subnet ID</div>
+        <div class="info-value">${this.instance.SubnetId || 'N/A'}</div>
+      </div>
+      
+      <div class="info-item">
+        <div class="info-label">Image ID</div>
+        <div class="info-value">${this.instance.ImageId}</div>
+      </div>
+      
+      <div class="info-item">
+        <div class="info-label">Launch Time</div>
+        <div class="info-value">${new Date(this.instance.LaunchTime).toLocaleString('pt-BR')}</div>
+      </div>
+      
+      ${proxyInfo}
+    </div>
+    
+    <div class="metadata-link">
+      <p><a href="/__metadata">📊 Ver Metadados Completos</a></p>
+    </div>
+    
+    <div class="footer">
+      <p>Simulador AWS Local | EC2 Instance</p>
+    </div>
+  </div>
+</body>
+</html>
+    `;
+  }
+
+  async start() {
+    return new Promise((resolve, reject) => {
+      try {
+        this.server = this.app.listen(this.instance.WebServerPort, 'localhost', () => {
+          logger.info(
+            `[EC2:${this.instance.InstanceId}] Servidor rodando em http://localhost:${this.instance.WebServerPort}`
+          );
+          resolve();
+        });
+
+        this.server.on('error', reject);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  async stop() {
+    if (this.server) {
+      return new Promise((resolve) => {
+        this.server.close(() => {
+          logger.info(`[EC2:${this.instance.InstanceId}] Servidor parado`);
+          resolve();
+        });
+      });
+    }
+  }
+}
+
+module.exports = InstanceServer;

package/src/services/ec2/models/ami.js

@@ -0,0 +1,39 @@
+/**
+ * AMI (Amazon Machine Image) Model
+ */
+
+class AMI {
+  constructor(name, description = '', config = {}) {
+    this.ImageId = `ami-${Math.random().toString(36).substring(7)}`;
+    this.Name = name;
+    this.Description = description;
+    this.Architecture = config.Architecture || 'x86_64';
+    this.RootDeviceType = config.RootDeviceType || 'ebs';
+    this.VirtualizationType = config.VirtualizationType || 'hvm';
+    this.State = 'available';
+    this.CreatedAt = new Date().toISOString();
+    this.Public = config.Public !== false;
+    this.Owner = config.Owner || '123456789012';
+    this.SriovNetSupport = config.SriovNetSupport || false;
+    this.EnaSupport = config.EnaSupport || true;
+  }
+
+  toJSON() {
+    return {
+      ImageId: this.ImageId,
+      Name: this.Name,
+      Description: this.Description,
+      Architecture: this.Architecture,
+      RootDeviceType: this.RootDeviceType,
+      VirtualizationType: this.VirtualizationType,
+      State: this.State,
+      CreatedAt: this.CreatedAt,
+      Public: this.Public,
+      Owner: this.Owner,
+      SriovNetSupport: this.SriovNetSupport,
+      EnaSupport: this.EnaSupport
+    };
+  }
+}
+
+module.exports = AMI;

package/src/services/ec2/models/instance.js

@@ -0,0 +1,98 @@
+/**
+ * EC2 Instance Model
+ */
+
+const { v4: uuidv4 } = require('uuid');
+
+class Instance {
+  constructor(imageId, instanceType = 't2.micro', config = {}) {
+    this.InstanceId = `i-${uuidv4().substring(0, 8)}`;
+    this.ImageId = imageId;
+    this.InstanceType = instanceType;
+    this.State = 'running'; // pending, running, stopping, stopped, shutting-down, terminated
+    this.StateTransitionReason = 'User initiated';
+    this.LaunchTime = new Date().toISOString();
+    this.PrivateIpAddress = config.PrivateIpAddress || this.generatePrivateIp();
+    this.PublicIpAddress = config.PublicIpAddress || this.generatePublicIp();
+    this.SubnetId = config.SubnetId || null;
+    this.VpcId = config.VpcId || null;
+    this.SecurityGroupIds = config.SecurityGroupIds || ['sg-default'];
+    this.KeyName = config.KeyName || null;
+    this.Tags = config.Tags || [];
+    this.Monitoring = config.Monitoring || { State: 'disabled' };
+    this.IamInstanceProfile = config.IamInstanceProfile || null;
+    this.EbsOptimized = config.EbsOptimized || false;
+    this.RootDeviceType = 'ebs';
+    this.Architecture = 'x86_64';
+    this.VirtualizationType = 'hvm';
+    this.Hypervisor = 'xen';
+    this.WebServerPort = config.WebServerPort || this.assignWebServerPort();
+    this.WebServerDir = config.WebServerDir || null;
+    this.ProxyUrl = config.ProxyUrl || null; // URL externa para proxy (ex: http://localhost:3000)
+    this.WebServer = null; // Será preenchido com a instância do servidor
+    this.CpuUtilization = 0;
+    this.MemoryUtilization = 0;
+  }
+
+  generatePrivateIp() {
+    return `10.0.${Math.floor(Math.random() * 255)}.${Math.floor(Math.random() * 255)}`;
+  }
+
+  generatePublicIp() {
+    return `54.${Math.floor(Math.random() * 255)}.${Math.floor(Math.random() * 255)}.${Math.floor(Math.random() * 255)}`;
+  }
+
+  assignWebServerPort() {
+    // Porta entre 8001 e 8999
+    return 8000 + Math.floor(Math.random() * 1000);
+  }
+
+  setState(state, reason = '') {
+    this.State = state;
+    this.StateTransitionReason = reason || this.StateTransitionReason;
+  }
+
+  isRunning() {
+    return this.State === 'running';
+  }
+
+  isStopped() {
+    return this.State === 'stopped';
+  }
+
+  isTerminated() {
+    return this.State === 'terminated';
+  }
+
+  toJSON() {
+    return {
+      InstanceId: this.InstanceId,
+      ImageId: this.ImageId,
+      InstanceType: this.InstanceType,
+      State: this.State,
+      StateTransitionReason: this.StateTransitionReason,
+      LaunchTime: this.LaunchTime,
+      PrivateIpAddress: this.PrivateIpAddress,
+      PublicIpAddress: this.PublicIpAddress,
+      SubnetId: this.SubnetId,
+      VpcId: this.VpcId,
+      SecurityGroupIds: this.SecurityGroupIds,
+      KeyName: this.KeyName,
+      Tags: this.Tags,
+      Monitoring: this.Monitoring,
+      IamInstanceProfile: this.IamInstanceProfile,
+      EbsOptimized: this.EbsOptimized,
+      RootDeviceType: this.RootDeviceType,
+      Architecture: this.Architecture,
+      VirtualizationType: this.VirtualizationType,
+      Hypervisor: this.Hypervisor,
+      WebServerPort: this.WebServerPort,
+      WebServerDir: this.WebServerDir,
+      ProxyUrl: this.ProxyUrl,
+      CpuUtilization: this.CpuUtilization,
+      MemoryUtilization: this.MemoryUtilization
+    };
+  }
+}
+
+module.exports = Instance;

package/src/services/ec2/models/networkInterface.js

@@ -0,0 +1,74 @@
+/**
+ * Network Interface Model
+ */
+
+const { v4: uuidv4 } = require('uuid');
+
+class NetworkInterface {
+  constructor(subnetId, vpcId, config = {}) {
+    this.NetworkInterfaceId = `eni-${uuidv4().substring(0, 8)}`;
+    this.SubnetId = subnetId;
+    this.VpcId = vpcId;
+    this.Description = config.Description || '';
+    this.PrivateIpAddresses = config.PrivateIpAddresses || [
+      {
+        PrivateIpAddress: `10.0.${Math.floor(Math.random() * 255)}.${Math.floor(Math.random() * 255)}`,
+        Primary: true
+      }
+    ];
+    this.Groups = config.Groups || [];
+    this.MacAddress = this.generateMacAddress();
+    this.Status = 'available'; // available, associated, detaching, detached
+    this.Attachment = config.Attachment || null;
+    this.SourceDestCheck = true;
+    this.Tags = config.Tags || [];
+    this.CreatedAt = new Date().toISOString();
+  }
+
+  generateMacAddress() {
+    return '02:' + Array(5)
+      .fill(0)
+      .map(() => Math.floor(Math.random() * 255).toString(16).padStart(2, '0'))
+      .join(':');
+  }
+
+  attachToInstance(instanceId, deviceIndex = 0) {
+    this.Attachment = {
+      AttachmentId: `eni-attach-${uuidv4().substring(0, 8)}`,
+      InstanceId: instanceId,
+      DeviceIndex: deviceIndex,
+      Status: 'attached',
+      AttachTime: new Date().toISOString()
+    };
+    this.Status = 'associated';
+  }
+
+  detachFromInstance() {
+    if (this.Attachment) {
+      this.Attachment.Status = 'detaching';
+      setTimeout(() => {
+        this.Attachment = null;
+        this.Status = 'available';
+      }, 1000);
+    }
+  }
+
+  toJSON() {
+    return {
+      NetworkInterfaceId: this.NetworkInterfaceId,
+      SubnetId: this.SubnetId,
+      VpcId: this.VpcId,
+      Description: this.Description,
+      PrivateIpAddresses: this.PrivateIpAddresses,
+      Groups: this.Groups,
+      MacAddress: this.MacAddress,
+      Status: this.Status,
+      Attachment: this.Attachment,
+      SourceDestCheck: this.SourceDestCheck,
+      Tags: this.Tags,
+      CreatedAt: this.CreatedAt
+    };
+  }
+}
+
+module.exports = NetworkInterface;

package/src/services/ec2/models/securityGroup.js

@@ -0,0 +1,71 @@
+/**
+ * Security Group Model
+ */
+
+const { v4: uuidv4 } = require('uuid');
+
+class SecurityGroup {
+  constructor(name, description = '', vpcId = null, config = {}) {
+    this.GroupId = `sg-${uuidv4().substring(0, 8)}`;
+    this.GroupName = name;
+    this.Description = description;
+    this.VpcId = vpcId;
+    this.OwnerId = '123456789012';
+    this.IpPermissions = [];
+    this.IpPermissionsEgress = [];
+    this.Tags = config.Tags || [];
+    this.CreatedAt = new Date().toISOString();
+    
+    // Adicionar regra padrão de saída (allow all)
+    this.addEgressRule('0.0.0.0/0', null, -1, -1);
+  }
+
+  addIngressRule(cidr, securityGroupId, fromPort, toPort, protocol = 'tcp', description = '') {
+    const rule = {
+      IpProtocol: protocol,
+      FromPort: fromPort,
+      ToPort: toPort,
+      IpRanges: cidr ? [{ CidrIp: cidr, Description: description }] : [],
+      UserIdGroupPairs: securityGroupId ? [{ GroupId: securityGroupId }] : [],
+      CreatedAt: new Date().toISOString()
+    };
+    this.IpPermissions.push(rule);
+    return rule;
+  }
+
+  addEgressRule(cidr, securityGroupId, fromPort, toPort, protocol = 'tcp', description = '') {
+    const rule = {
+      IpProtocol: protocol,
+      FromPort: fromPort,
+      ToPort: toPort,
+      IpRanges: cidr ? [{ CidrIp: cidr, Description: description }] : [],
+      UserIdGroupPairs: securityGroupId ? [{ GroupId: securityGroupId }] : [],
+      CreatedAt: new Date().toISOString()
+    };
+    this.IpPermissionsEgress.push(rule);
+    return rule;
+  }
+
+  removeIngressRule(index) {
+    if (index >= 0 && index < this.IpPermissions.length) {
+      return this.IpPermissions.splice(index, 1)[0];
+    }
+    throw new Error(`Invalid rule index: ${index}`);
+  }
+
+  toJSON() {
+    return {
+      GroupId: this.GroupId,
+      GroupName: this.GroupName,
+      Description: this.Description,
+      VpcId: this.VpcId,
+      OwnerId: this.OwnerId,
+      IpPermissions: this.IpPermissions,
+      IpPermissionsEgress: this.IpPermissionsEgress,
+      Tags: this.Tags,
+      CreatedAt: this.CreatedAt
+    };
+  }
+}
+
+module.exports = SecurityGroup;