@gugananuvem/aws-local-simulator 1.0.35 → 1.0.39

package/src/services/ec2/server.js

@@ -0,0 +1,350 @@
+const { setupServiceMiddleware } = require('../../middleware');
+/**
+ * EC2 Server - API REST com 30+ endpoints
+ */
+
+const express = require('express');
+const logger = require('../../utils/logger');
+
+class EC2Server {
+  constructor(port, config) {
+    this.organizationsService = null;
+    this.stsService = null;
+    this.port = port;
+    this.config = config;
+    this.app = express();
+    this.simulator = null;
+  }
+
+  setupMiddlewares() {
+    this.app.use(express.json());
+    this.app.use((req, res, next) => {
+      logger.debug(`EC2 Request: ${req.method} ${req.path}`);
+      next();
+    });
+  }
+
+  async initialize() {
+    logger.debug(`Inicializando EC2 Server na porta ${this.port}`);
+    this.setupMiddlewares();
+    this.setupRoutes();
+  }
+
+  setupRoutes() {
+    // ========== Instance Routes ==========
+
+    // Run Instances
+    this.app.post('/__admin/ec2/instances/run', (req, res) => {
+      try {
+        const { ImageId, MinCount = 1, MaxCount = 1, InstanceType = 't2.micro', ...config } =
+          req.body;
+
+        if (!ImageId) {
+          return res.status(400).json({ error: 'ImageId is required' });
+        }
+
+        const instances = this.simulator.runInstances(ImageId, MinCount, InstanceType, config);
+
+        // Iniciar servidores web para as instâncias
+        instances.forEach(async (instance) => {
+          // ProxyUrl tem prioridade sobre WebServerDir
+          if (config.ProxyUrl) {
+            await this.simulator.startInstanceServer(instance.InstanceId, null, config.ProxyUrl);
+          } else if (config.WebServerDir) {
+            await this.simulator.startInstanceServer(instance.InstanceId, config.WebServerDir);
+          } else {
+            await this.simulator.startInstanceServer(instance.InstanceId);
+          }
+        });
+
+        res.json({ Instances: instances.map(i => i.toJSON()) });
+      } catch (error) {
+        logger.error(`Error running instances: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Describe Instances
+    this.app.get('/__admin/ec2/instances', (req, res) => {
+      try {
+        const filters = {};
+        if (req.query.instanceIds) {
+          filters.instanceIds = Array.isArray(req.query.instanceIds)
+            ? req.query.instanceIds
+            : [req.query.instanceIds];
+        }
+        if (req.query.state) {
+          filters.state = req.query.state;
+        }
+
+        const instances = this.simulator.describeInstances(filters);
+        res.json({ Instances: instances.map(i => i.toJSON()) });
+      } catch (error) {
+        logger.error(`Error describing instances: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Get Instance
+    this.app.get('/__admin/ec2/instances/:instanceId', (req, res) => {
+      try {
+        const instance = this.simulator.getInstance(req.params.instanceId);
+        res.json({ Instance: instance.toJSON() });
+      } catch (error) {
+        logger.error(`Error getting instance: ${error.message}`);
+        res.status(404).json({ error: error.message });
+      }
+    });
+
+    // Start Instances
+    this.app.post('/__admin/ec2/instances/:instanceId/start', (req, res) => {
+      try {
+        const instances = this.simulator.startInstances([req.params.instanceId]);
+        res.json({ Instances: instances.map(i => i.toJSON()) });
+      } catch (error) {
+        logger.error(`Error starting instance: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Stop Instances
+    this.app.post('/__admin/ec2/instances/:instanceId/stop', (req, res) => {
+      try {
+        const instances = this.simulator.stopInstances([req.params.instanceId]);
+        res.json({ Instances: instances.map(i => i.toJSON()) });
+      } catch (error) {
+        logger.error(`Error stopping instance: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Reboot Instances
+    this.app.post('/__admin/ec2/instances/:instanceId/reboot', (req, res) => {
+      try {
+        const instances = this.simulator.rebootInstances([req.params.instanceId]);
+        res.json({ Instances: instances.map(i => i.toJSON()) });
+      } catch (error) {
+        logger.error(`Error rebooting instance: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Terminate Instances
+    this.app.post('/__admin/ec2/instances/:instanceId/terminate', (req, res) => {
+      try {
+        const instances = this.simulator.terminateInstances([req.params.instanceId]);
+        res.json({ Instances: instances.map(i => i.toJSON()) });
+      } catch (error) {
+        logger.error(`Error terminating instance: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Describe Instance Status
+    this.app.get('/__admin/ec2/instances/:instanceId/status', (req, res) => {
+      try {
+        const instance = this.simulator.getInstance(req.params.instanceId);
+        res.json({
+          InstanceId: instance.InstanceId,
+          State: instance.State,
+          StateTransitionReason: instance.StateTransitionReason,
+          WebServerPort: instance.WebServerPort,
+          WebServerUrl: `http://localhost:${instance.WebServerPort}`,
+          PublicIp: instance.PublicIpAddress,
+          PrivateIp: instance.PrivateIpAddress
+        });
+      } catch (error) {
+        logger.error(`Error getting instance status: ${error.message}`);
+        res.status(404).json({ error: error.message });
+      }
+    });
+
+    // ========== Image Routes ==========
+
+    // Describe Images
+    this.app.get('/__admin/ec2/images', (req, res) => {
+      try {
+        const images = this.simulator.describeImages();
+        res.json({ Images: images.map(img => img.toJSON()) });
+      } catch (error) {
+        logger.error(`Error describing images: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // ========== Security Group Routes ==========
+
+    // Create Security Group
+    this.app.post('/__admin/ec2/security-groups/create', (req, res) => {
+      try {
+        const { GroupName, Description = '', VpcId = null } = req.body;
+
+        if (!GroupName) {
+          return res.status(400).json({ error: 'GroupName is required' });
+        }
+
+        const sg = this.simulator.createSecurityGroup(GroupName, Description, VpcId);
+        res.json({ SecurityGroup: sg.toJSON() });
+      } catch (error) {
+        logger.error(`Error creating security group: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Describe Security Groups
+    this.app.get('/__admin/ec2/security-groups', (req, res) => {
+      try {
+        const filters = {};
+        if (req.query.groupIds) {
+          filters.groupIds = Array.isArray(req.query.groupIds)
+            ? req.query.groupIds
+            : [req.query.groupIds];
+        }
+
+        const sgs = this.simulator.describeSecurityGroups(filters);
+        res.json({ SecurityGroups: sgs.map(sg => sg.toJSON()) });
+      } catch (error) {
+        logger.error(`Error describing security groups: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Get Security Group
+    this.app.get('/__admin/ec2/security-groups/:groupId', (req, res) => {
+      try {
+        const sg = this.simulator.getSecurityGroup(req.params.groupId);
+        res.json({ SecurityGroup: sg.toJSON() });
+      } catch (error) {
+        logger.error(`Error getting security group: ${error.message}`);
+        res.status(404).json({ error: error.message });
+      }
+    });
+
+    // Add Ingress Rule
+    this.app.post('/__admin/ec2/security-groups/:groupId/ingress', (req, res) => {
+      try {
+        const { CidrIp, FromPort, ToPort, Protocol = 'tcp', Description = '' } = req.body;
+
+        if (!FromPort || !ToPort) {
+          return res.status(400).json({ error: 'FromPort and ToPort are required' });
+        }
+
+        const sg = this.simulator.getSecurityGroup(req.params.groupId);
+        const rule = sg.addIngressRule(CidrIp, null, FromPort, ToPort, Protocol, Description);
+
+        res.json({ Rule: rule });
+      } catch (error) {
+        logger.error(`Error adding ingress rule: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Delete Security Group
+    this.app.delete('/__admin/ec2/security-groups/:groupId', (req, res) => {
+      try {
+        this.simulator.deleteSecurityGroup(req.params.groupId);
+        res.json({ success: true });
+      } catch (error) {
+        logger.error(`Error deleting security group: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // ========== Network Interface Routes ==========
+
+    // Describe Network Interfaces
+    this.app.get('/__admin/ec2/network-interfaces', (req, res) => {
+      try {
+        const filters = {};
+        if (req.query.networkInterfaceIds) {
+          filters.networkInterfaceIds = Array.isArray(req.query.networkInterfaceIds)
+            ? req.query.networkInterfaceIds
+            : [req.query.networkInterfaceIds];
+        }
+
+        const enis = this.simulator.describeNetworkInterfaces(filters);
+        res.json({ NetworkInterfaces: enis.map(eni => eni.toJSON()) });
+      } catch (error) {
+        logger.error(`Error describing network interfaces: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Get Network Interface
+    this.app.get('/__admin/ec2/network-interfaces/:eniId', (req, res) => {
+      try {
+        const eni = this.simulator.getNetworkInterface(req.params.eniId);
+        res.json({ NetworkInterface: eni.toJSON() });
+      } catch (error) {
+        logger.error(`Error getting network interface: ${error.message}`);
+        res.status(404).json({ error: error.message });
+      }
+    });
+
+    // ========== Utility Routes ==========
+
+    // Health Check
+    this.app.get('/__admin/ec2/health', (req, res) => {
+      res.json({ status: 'ok', service: 'ec2' });
+    });
+
+    // Get All Resources
+    this.app.get('/__admin/ec2/resources', (req, res) => {
+      try {
+        const resources = this.simulator.getAllResources();
+        res.json({
+          instances: resources.instances.map(i => i.toJSON()),
+          amis: resources.amis.map(a => a.toJSON()),
+          securityGroups: resources.securityGroups.map(sg => sg.toJSON()),
+          networkInterfaces: resources.networkInterfaces.map(eni => eni.toJSON()),
+          instanceServersCount: resources.instanceServersCount
+        });
+      } catch (error) {
+        logger.error(`Error fetching resources: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Get Running Instances (simplificado)
+    this.app.get('/__admin/ec2/instances-running', (req, res) => {
+      try {
+        const instances = this.simulator.describeInstances({ state: 'running' });
+        res.json({
+          count: instances.length,
+          instances: instances.map(i => ({
+            InstanceId: i.InstanceId,
+            PublicIp: i.PublicIpAddress,
+            PrivateIp: i.PrivateIpAddress,
+            WebServerPort: i.WebServerPort,
+            WebServerUrl: `http://localhost:${i.WebServerPort}`
+          }))
+        });
+      } catch (error) {
+        logger.error(`Error getting running instances: ${error.message}`);
+        res.status(400).json({ error: error.message });
+      }
+    });
+  }
+
+  async start() {
+    return new Promise((resolve) => {
+      this.server = this.app.listen(this.port, () => {
+        logger.info(`EC2 Server running on http://localhost:${this.port}`);
+        resolve();
+      });
+    });
+  }
+
+  async stop() {
+    if (this.server) {
+      return new Promise((resolve) => {
+        this.server.close(() => {
+          logger.info('EC2 Server stopped');
+          resolve();
+        });
+      });
+    }
+  }
+}
+
+module.exports = EC2Server;