@gugananuvem/aws-local-simulator 1.0.34 → 1.0.39

package/src/services/ec2/simulator.js

@@ -0,0 +1,436 @@
+/**
+ * EC2 Simulator
+ * Gerencia instâncias, AMIs, security groups e network interfaces com persistência
+ */
+
+const path = require('path');
+const Instance = require('./models/instance');
+const AMI = require('./models/ami');
+const SecurityGroup = require('./models/securityGroup');
+const NetworkInterface = require('./models/networkInterface');
+const InstanceServer = require('./instanceServer');
+const LocalStore = require('../../utils/local-store');
+const logger = require('../../utils/logger');
+
+class EC2Simulator {
+  constructor(config = {}) {
+    this.config = config;
+    this.instances = new Map();
+    this.amis = new Map();
+    this.securityGroups = new Map();
+    this.networkInterfaces = new Map();
+    this.instanceServers = new Map();
+    this.instanceCounter = 0;
+
+    // Inicializar persistência
+    const dataDir = process.env.AWS_LOCAL_SIMULATOR_DATA_DIR || config.dataDir || './.aws-local-simulator-data';
+    this.dataDir = path.join(dataDir, 'ec2');
+    this.store = new LocalStore(this.dataDir);
+  }
+
+  async initialize() {
+    // 1. Carregar dados persistidos
+    await this.loadFromPersistence();
+
+    // 2. Se não houver dados, criar AMIs e security groups padrão
+    if (this.amis.size === 0) {
+      this.createDefaultAMIs();
+    }
+
+    if (this.securityGroups.size === 0) {
+      this.createDefaultSecurityGroup();
+    }
+
+    // 3. Pré-provisionar instâncias se configurado e não existirem
+    if (this.instances.size === 0 && this.config.instances && Array.isArray(this.config.instances)) {
+      logger.info('📚 Carregando Instâncias EC2 da configuração inicial...');
+      for (const instanceConfig of this.config.instances) {
+        const instance = this.runInstances(
+          instanceConfig.ImageId || 'ami-default',
+          1,
+          instanceConfig.InstanceType || 't2.micro',
+          instanceConfig
+        )[0];
+
+        // Se houver website dir, iniciar servidor
+        if (instanceConfig.WebServerDir) {
+          await this.startInstanceServer(instance.InstanceId, instanceConfig.WebServerDir);
+        }
+      }
+    }
+  }
+
+  /**
+   * Carrega dados persistidos do storage
+   */
+  async loadFromPersistence() {
+    try {
+      // Carregar AMIs
+      const amisData = this.store.read('amis');
+      if (Array.isArray(amisData)) {
+        logger.info(`📂 Carregando ${amisData.length} AMIs do storage...`);
+        for (const amiData of amisData) {
+          const ami = new AMI(amiData.Name, amiData.Architecture, amiData.RootDeviceType);
+          ami.ImageId = amiData.ImageId;
+          this.amis.set(ami.ImageId, ami);
+        }
+      }
+
+      // Carregar Security Groups
+      const sgsData = this.store.read('security-groups');
+      if (Array.isArray(sgsData)) {
+        logger.info(`📂 Carregando ${sgsData.length} Security Groups do storage...`);
+        for (const sgData of sgsData) {
+          const sg = new SecurityGroup(sgData.GroupName, sgData.Description, sgData.VpcId);
+          sg.GroupId = sgData.GroupId;
+          sg.IngressRules = sgData.IngressRules || [];
+          sg.EgressRules = sgData.EgressRules || [];
+          this.securityGroups.set(sg.GroupId, sg);
+        }
+      }
+
+      // Carregar Network Interfaces
+      const nisData = this.store.read('network-interfaces');
+      if (Array.isArray(nisData)) {
+        logger.info(`📂 Carregando ${nisData.length} Network Interfaces do storage...`);
+        for (const niData of nisData) {
+          const ni = new NetworkInterface(niData.SubnetId, niData.VpcId);
+          ni.NetworkInterfaceId = niData.NetworkInterfaceId;
+          ni.PrivateIpAddress = niData.PrivateIpAddress;
+          ni.SecurityGroups = niData.SecurityGroups || [];
+          this.networkInterfaces.set(ni.NetworkInterfaceId, ni);
+        }
+      }
+
+      // Carregar Instâncias
+      const instancesData = this.store.read('instances');
+      if (Array.isArray(instancesData)) {
+        logger.info(`📂 Carregando ${instancesData.length} Instâncias do storage...`);
+        for (const instData of instancesData) {
+          const instance = new Instance(instData.ImageId, instData.InstanceType, instData.SecurityGroupIds);
+          instance.InstanceId = instData.InstanceId;
+          instance.State = instData.State;
+          instance.LaunchTime = instData.LaunchTime;
+          instance.PublicIpAddress = instData.PublicIpAddress;
+          instance.PrivateIpAddress = instData.PrivateIpAddress;
+          instance.Tags = instData.Tags || [];
+          this.instances.set(instance.InstanceId, instance);
+        }
+      }
+    } catch (error) {
+      logger.warn(`⚠️  Erro ao carregar dados persistidos EC2: ${error.message}`);
+    }
+  }
+
+  /**
+   * Persiste estado atual em storage
+   */
+  persistData() {
+    try {
+      this.store.write('amis', Array.from(this.amis.values()).map(a => a.toJSON ? a.toJSON() : a));
+      this.store.write('security-groups', Array.from(this.securityGroups.values()).map(sg => sg.toJSON ? sg.toJSON() : sg));
+      this.store.write('network-interfaces', Array.from(this.networkInterfaces.values()).map(ni => ni.toJSON ? ni.toJSON() : ni));
+      this.store.write('instances', Array.from(this.instances.values()).map(i => i.toJSON ? i.toJSON() : i));
+    } catch (error) {
+      logger.error(`Erro ao persistir dados EC2: ${error.message}`);
+    }
+  }
+
+  createDefaultAMIs() {
+    const amis = [
+      { name: 'ubuntu-20.04', desc: 'Ubuntu 20.04 LTS' },
+      { name: 'ubuntu-22.04', desc: 'Ubuntu 22.04 LTS' },
+      { name: 'amazon-linux-2', desc: 'Amazon Linux 2' },
+      { name: 'debian-11', desc: 'Debian 11' }
+    ];
+
+    amis.forEach(ami => {
+      const newAmi = new AMI(ami.name, ami.desc);
+      this.amis.set(newAmi.ImageId, newAmi);
+    });
+
+    logger.debug(`✅ ${amis.length} AMIs padrão criadas`);
+  }
+
+  createDefaultSecurityGroup() {
+    const sg = new SecurityGroup('default', 'Security group padrão');
+    sg.addIngressRule('0.0.0.0/0', null, 80, 80, 'tcp', 'HTTP');
+    sg.addIngressRule('0.0.0.0/0', null, 443, 443, 'tcp', 'HTTPS');
+    sg.addIngressRule('0.0.0.0/0', null, 22, 22, 'tcp', 'SSH');
+    this.securityGroups.set(sg.GroupId, sg);
+    logger.debug(`✅ Security group padrão criado: ${sg.GroupId}`);
+  }
+
+  // ========== Instance Operations ==========
+
+  runInstances(imageId, count = 1, instanceType = 't2.micro', config = {}) {
+    const ami = this.amis.get(imageId) || this.getFirstAMI();
+    if (!ami) {
+      throw new Error(`AMI ${imageId} not found`);
+    }
+
+    const instances = [];
+
+    for (let i = 0; i < count; i++) {
+      const instance = new Instance(imageId, instanceType, {
+        SubnetId: config.SubnetId,
+        VpcId: config.VpcId,
+        SecurityGroupIds: config.SecurityGroupIds || ['sg-default'],
+        KeyName: config.KeyName,
+        Tags: config.Tags,
+        WebServerDir: config.WebServerDir,
+        ProxyUrl: config.ProxyUrl // Passar ProxyUrl se configurado
+      });
+
+      this.instances.set(instance.InstanceId, instance);
+
+      // Criar network interface para a instância
+      if (config.SubnetId && config.VpcId) {
+        const eni = new NetworkInterface(config.SubnetId, config.VpcId);
+        eni.attachToInstance(instance.InstanceId, 0);
+        this.networkInterfaces.set(eni.NetworkInterfaceId, eni);
+      }
+
+      instances.push(instance);
+      logger.info(`✅ Instância criada: ${instance.InstanceId} (${instanceType})`);
+    }
+
+    // ✅ Persistir mudanças
+    this.persistData();
+
+    return instances;
+  }
+
+  describeInstances(filters = {}) {
+    let instances = Array.from(this.instances.values());
+
+    if (filters.instanceIds && Array.isArray(filters.instanceIds)) {
+      instances = instances.filter(i => filters.instanceIds.includes(i.InstanceId));
+    }
+
+    if (filters.state) {
+      instances = instances.filter(i => i.State === filters.state);
+    }
+
+    if (filters.vpcIds && Array.isArray(filters.vpcIds)) {
+      instances = instances.filter(i => filters.vpcIds.includes(i.VpcId));
+    }
+
+    return instances;
+  }
+
+  getInstance(instanceId) {
+    const instance = this.instances.get(instanceId);
+    if (!instance) {
+      throw new Error(`Instance ${instanceId} not found`);
+    }
+    return instance;
+  }
+
+  startInstances(instanceIds) {
+    const instances = [];
+    for (const instanceId of instanceIds) {
+      const instance = this.getInstance(instanceId);
+      instance.setState('running', 'User initiated');
+      instances.push(instance);
+      logger.info(`✅ Instância iniciada: ${instanceId}`);
+    }
+    // ✅ Persistir mudanças
+    this.persistData();
+    return instances;
+  }
+
+  stopInstances(instanceIds) {
+    const instances = [];
+    for (const instanceId of instanceIds) {
+      const instance = this.getInstance(instanceId);
+      instance.setState('stopped', 'User initiated');
+      instances.push(instance);
+      logger.info(`⏸️ Instância parada: ${instanceId}`);
+    }
+    // ✅ Persistir mudanças
+    this.persistData();
+    return instances;
+  }
+
+  rebootInstances(instanceIds) {
+    const instances = [];
+    for (const instanceId of instanceIds) {
+      const instance = this.getInstance(instanceId);
+      // Simular reinício: running -> stopping -> running
+      instance.setState('stopping', 'Rebooting');
+      setTimeout(() => {
+        instance.setState('running', 'Reboot complete');
+        this.persistData();
+      }, 100);
+      instances.push(instance);
+      logger.info(`🔄 Instância reiniciada: ${instanceId}`);
+    }
+    return instances;
+  }
+
+  terminateInstances(instanceIds) {
+    const instances = [];
+    for (const instanceId of instanceIds) {
+      const instance = this.getInstance(instanceId);
+      instance.setState('terminated', 'User initiated');
+      
+      // Parar servidor web se estiver rodando
+      if (this.instanceServers.has(instanceId)) {
+        this.stopInstanceServer(instanceId);
+      }
+
+      instances.push(instance);
+      logger.info(`🗑️ Instância terminada: ${instanceId}`);
+    }
+    // ✅ Persistir mudanças
+    this.persistData();
+    return instances;
+  }
+
+  // ========== Instance Server Operations ==========
+
+  async startInstanceServer(instanceId, websiteDir = null, proxyUrl = null) {
+    const instance = this.getInstance(instanceId);
+
+    if (this.instanceServers.has(instanceId)) {
+      throw new Error(`Instance server already running for ${instanceId}`);
+    }
+
+    // Se ProxyUrl foi fornecido, atualizar a instância
+    if (proxyUrl) {
+      instance.ProxyUrl = proxyUrl;
+    }
+
+    try {
+      const server = new InstanceServer(instance, websiteDir);
+      await server.start();
+      this.instanceServers.set(instanceId, server);
+      
+      const serverType = proxyUrl ? '🔗 Proxy' : '🌐 Web';
+      const target = proxyUrl ? `→ ${proxyUrl}` : websiteDir ? `→ ${websiteDir}` : '';
+      logger.info(`${serverType} servidor iniciado para ${instanceId} ${target}`);
+    } catch (error) {
+      logger.error(`Erro ao iniciar servidor web para ${instanceId}:`, error.message);
+      throw error;
+    }
+  }
+
+  async stopInstanceServer(instanceId) {
+    const server = this.instanceServers.get(instanceId);
+    if (server) {
+      await server.stop();
+      this.instanceServers.delete(instanceId);
+      logger.info(`🌐 Servidor web parado para ${instanceId}`);
+    }
+  }
+
+  getInstanceServerPort(instanceId) {
+    const instance = this.getInstance(instanceId);
+    return instance.WebServerPort;
+  }
+
+  // ========== AMI Operations ==========
+
+  describeImages(filters = {}) {
+    let amis = Array.from(this.amis.values());
+
+    if (filters.imageIds && Array.isArray(filters.imageIds)) {
+      amis = amis.filter(a => filters.imageIds.includes(a.ImageId));
+    }
+
+    return amis;
+  }
+
+  getFirstAMI() {
+    return this.amis.values().next().value;
+  }
+
+  // ========== Security Group Operations ==========
+
+  createSecurityGroup(name, description = '', vpcId = null, config = {}) {
+    const sg = new SecurityGroup(name, description, vpcId, config);
+    this.securityGroups.set(sg.GroupId, sg);
+    return sg;
+  }
+
+  describeSecurityGroups(filters = {}) {
+    let sgs = Array.from(this.securityGroups.values());
+
+    if (filters.groupIds && Array.isArray(filters.groupIds)) {
+      sgs = sgs.filter(sg => filters.groupIds.includes(sg.GroupId));
+    }
+
+    if (filters.groupNames && Array.isArray(filters.groupNames)) {
+      sgs = sgs.filter(sg => filters.groupNames.includes(sg.GroupName));
+    }
+
+    return sgs;
+  }
+
+  getSecurityGroup(groupId) {
+    const sg = this.securityGroups.get(groupId);
+    if (!sg) {
+      throw new Error(`Security Group ${groupId} not found`);
+    }
+    return sg;
+  }
+
+  deleteSecurityGroup(groupId) {
+    // Verificar se está em uso
+    const inUse = Array.from(this.instances.values()).some(i =>
+      i.SecurityGroupIds.includes(groupId)
+    );
+
+    if (inUse) {
+      throw new Error(`Cannot delete security group ${groupId}: in use`);
+    }
+
+    this.securityGroups.delete(groupId);
+    return true;
+  }
+
+  // ========== Network Interface Operations ==========
+
+  createNetworkInterface(subnetId, vpcId, config = {}) {
+    const eni = new NetworkInterface(subnetId, vpcId, config);
+    this.networkInterfaces.set(eni.NetworkInterfaceId, eni);
+    return eni;
+  }
+
+  describeNetworkInterfaces(filters = {}) {
+    let enis = Array.from(this.networkInterfaces.values());
+
+    if (filters.networkInterfaceIds && Array.isArray(filters.networkInterfaceIds)) {
+      enis = enis.filter(e => filters.networkInterfaceIds.includes(e.NetworkInterfaceId));
+    }
+
+    if (filters.subnetIds && Array.isArray(filters.subnetIds)) {
+      enis = enis.filter(e => filters.subnetIds.includes(e.SubnetId));
+    }
+
+    return enis;
+  }
+
+  getNetworkInterface(eniId) {
+    const eni = this.networkInterfaces.get(eniId);
+    if (!eni) {
+      throw new Error(`Network Interface ${eniId} not found`);
+    }
+    return eni;
+  }
+
+  // ========== Utility ==========
+
+  getAllResources() {
+    return {
+      instances: Array.from(this.instances.values()),
+      amis: Array.from(this.amis.values()),
+      securityGroups: Array.from(this.securityGroups.values()),
+      networkInterfaces: Array.from(this.networkInterfaces.values()),
+      instanceServersCount: this.instanceServers.size
+    };
+  }
+}
+
+module.exports = EC2Simulator;

package/src/services/eventbridge/server.js

@@ -59,6 +59,42 @@ function createEventBridgeServer(simulator, config, logger) {
     } catch (err) { sendError(res, err); }
   });
 
+  // ==================== JSON routes for React frontend ====================
+
+  app.post('/json/eventbridge/rules', async (req, res) => {
+    try {
+      const result = await simulator.putRule(req.body);
+      res.status(201).json(result);
+    } catch (err) { sendError(res, err); }
+  });
+
+  app.delete('/json/eventbridge/rules/:name', async (req, res) => {
+    try {
+      await simulator.deleteRule({ Name: req.params.name, EventBusName: req.query.eventBusName });
+      res.status(200).json({});
+    } catch (err) { sendError(res, err); }
+  });
+
+  app.get('/json/eventbridge/rules', (req, res) => {
+    try {
+      const result = simulator.listRules({
+        EventBusName: req.query.EventBusName || 'default',
+        NamePrefix: req.query.NamePrefix,
+        Limit: req.query.Limit ? parseInt(req.query.Limit) : undefined
+      });
+      // Return just the array, not the wrapper object
+      res.json(result.Rules || []);
+    } catch (err) { sendError(res, err); }
+  });
+
+  app.get('/json/eventbridge/buses', (req, res) => {
+    try {
+      const result = simulator.listEventBuses();
+      // Return just the array, not the wrapper object
+      res.json(result.EventBuses || []);
+    } catch (err) { sendError(res, err); }
+  });
+
   // ==================== Rules ====================
 
   app.put('/rules', async (req, res) => {