@gugananuvem/aws-local-simulator 1.0.35 → 1.0.39

package/src/services/alb/index.js

@@ -0,0 +1,104 @@
+/**
+ * ALB Service - Ponto de entrada
+ */
+
+const ALBServer = require('./server');
+const ALBSimulator = require('./simulator');
+
+class ALBService {
+  constructor(config) {
+    this.config = config;
+    this.name = 'alb';
+    this.port = config.ports.alb || 4021;
+    this.server = null;
+    this.simulator = null;
+    this.isRunning = false;
+  }
+
+  async initialize() {
+    const logger = require('../../utils/logger');
+    logger.debug(`Inicializando ALB Service na porta ${this.port}...`);
+
+    this.simulator = new ALBSimulator(this.config.alb || {});
+    await this.simulator.initialize();
+
+    this.server = new ALBServer(this.port, this.config);
+    this.server.simulator = this.simulator;
+
+    await this.server.initialize();
+
+    logger.debug('ALB Service inicializado');
+  }
+
+  injectDependencies(server) {
+    // Aqui você pode injetar dependências de outros serviços se necessário
+    // Por exemplo, integração com EC2 para health checks
+  }
+
+  async start() {
+    const logger = require('../../utils/logger');
+
+    if (this.isRunning) {
+      logger.warn('ALB Service já está em execução');
+      return;
+    }
+
+    try {
+      await this.server.start();
+      this.isRunning = true;
+      logger.info('ALB Service iniciado com sucesso');
+    } catch (error) {
+      logger.error(`Erro ao iniciar ALB Service: ${error.message}`);
+      throw error;
+    }
+  }
+
+  async stop() {
+    const logger = require('../../utils/logger');
+
+    if (!this.isRunning) {
+      logger.warn('ALB Service não está em execução');
+      return;
+    }
+
+    try {
+      await this.server.stop();
+      this.isRunning = false;
+      logger.info('ALB Service parado com sucesso');
+    } catch (error) {
+      logger.error(`Erro ao parar ALB Service: ${error.message}`);
+      throw error;
+    }
+  }
+
+  getSimulator() {
+    return this.simulator;
+  }
+
+  getStatus() {
+    const resources = this.simulator.getAllResources();
+    const totalTargets = resources.targetGroups.reduce(
+      (sum, tg) => sum + tg.Targets.length,
+      0
+    );
+    const healthyTargets = resources.targetGroups.reduce((sum, tg) => {
+      return sum + tg.Targets.filter(t => t.HealthState === 'healthy').length;
+    }, 0);
+
+    return {
+      name: this.name,
+      running: this.isRunning,
+      port: this.port,
+      endpoint: `http://localhost:${this.port}`,
+      resources: {
+        loadBalancersCount: resources.loadBalancers.length,
+        targetGroupsCount: resources.targetGroups.length,
+        totalTargets,
+        healthyTargets,
+        unhealthyTargets: totalTargets - healthyTargets
+      }
+    };
+  }
+}
+
+module.exports = ALBService;

package/src/services/alb/models/loadBalancer.js

@@ -0,0 +1,88 @@
+/**
+ * Application Load Balancer Model
+ */
+
+const { v4: uuidv4 } = require('uuid');
+
+class LoadBalancer {
+  constructor(name, scheme = 'internet-facing', config = {}) {
+    this.LoadBalancerArn = `arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/app/${name}/${uuidv4().substring(0, 8)}`;
+    this.LoadBalancerName = name;
+    this.DNSName = `${name}-${Math.random().toString(36).substring(7)}.elb.us-east-1.amazonaws.com`;
+    this.Scheme = scheme; // internet-facing ou internal
+    this.Type = 'application';
+    this.State = 'active';
+    this.VpcId = config.VpcId || null;
+    this.SubnetIds = config.SubnetIds || [];
+    this.SecurityGroupIds = config.SecurityGroupIds || [];
+    this.IpAddressType = config.IpAddressType || 'ipv4';
+    this.Listeners = [];
+    this.TargetGroups = [];
+    this.Tags = config.Tags || [];
+    this.CreatedTime = new Date().toISOString();
+    this.Port = config.Port || 80;
+  }
+
+  addListener(protocol = 'HTTP', port = 80, targetGroupArn = null) {
+    const listener = {
+      ListenerArn: `arn:aws:elasticloadbalancing:us-east-1:123456789012:listener/app/${uuidv4().substring(0, 8)}`,
+      LoadBalancerArn: this.LoadBalancerArn,
+      Port: port,
+      Protocol: protocol,
+      Certificates: [],
+      DefaultActions: [
+        {
+          Type: 'forward',
+          TargetGroupArn: targetGroupArn
+        }
+      ],
+      AlpnPolicy: []
+    };
+    this.Listeners.push(listener);
+    return listener;
+  }
+
+  addTargetGroup(targetGroup) {
+    this.TargetGroups.push(targetGroup);
+  }
+
+  removeTargetGroup(targetGroupArn) {
+    const index = this.TargetGroups.findIndex(tg => tg.TargetGroupArn === targetGroupArn);
+    if (index > -1) {
+      this.TargetGroups.splice(index, 1);
+    }
+  }
+
+  getHealthyTargets() {
+    const healthyTargets = [];
+    this.TargetGroups.forEach(tg => {
+      tg.Targets.forEach(target => {
+        if (target.HealthState === 'healthy') {
+          healthyTargets.push(target);
+        }
+      });
+    });
+    return healthyTargets;
+  }
+
+  toJSON() {
+    return {
+      LoadBalancerArn: this.LoadBalancerArn,
+      LoadBalancerName: this.LoadBalancerName,
+      DNSName: this.DNSName,
+      Scheme: this.Scheme,
+      Type: this.Type,
+      State: this.State,
+      VpcId: this.VpcId,
+      SubnetIds: this.SubnetIds,
+      SecurityGroupIds: this.SecurityGroupIds,
+      IpAddressType: this.IpAddressType,
+      CreatedTime: this.CreatedTime,
+      Port: this.Port,
+      ListenersCount: this.Listeners.length,
+      TargetGroupsCount: this.TargetGroups.length
+    };
+  }
+}
+
+module.exports = LoadBalancer;

package/src/services/alb/models/targetGroup.js

@@ -0,0 +1,128 @@
+/**
+ * Target Group Model
+ */
+
+const { v4: uuidv4 } = require('uuid');
+
+class Target {
+  constructor(targetId, port = 80) {
+    this.TargetId = targetId; // instance-id ou IP
+    this.Port = port;
+    this.HealthState = 'healthy';
+    this.HealthReason = 'N/A';
+    this.Description = 'Target registered';
+    this.RegisteredAt = new Date().toISOString();
+  }
+
+  setHealthy() {
+    this.HealthState = 'healthy';
+    this.HealthReason = 'N/A';
+  }
+
+  setUnhealthy(reason = 'Health checks failed') {
+    this.HealthState = 'unhealthy';
+    this.HealthReason = reason;
+  }
+
+  toJSON() {
+    return {
+      TargetId: this.TargetId,
+      Port: this.Port,
+      HealthState: this.HealthState,
+      HealthReason: this.HealthReason,
+      Description: this.Description,
+      RegisteredAt: this.RegisteredAt
+    };
+  }
+}
+
+class TargetGroup {
+  constructor(name, protocol = 'HTTP', port = 80, vpcId = null, config = {}) {
+    this.TargetGroupArn = `arn:aws:elasticloadbalancing:us-east-1:123456789012:targetgroup/${name}/${uuidv4().substring(0, 8)}`;
+    this.TargetGroupName = name;
+    this.Protocol = protocol;
+    this.Port = port;
+    this.VpcId = vpcId;
+    this.TargetType = config.TargetType || 'instance'; // instance ou ip
+    this.Targets = [];
+    this.HealthCheckEnabled = config.HealthCheckEnabled !== false;
+    this.HealthCheckProtocol = config.HealthCheckProtocol || 'HTTP';
+    this.HealthCheckPath = config.HealthCheckPath || '/';
+    this.HealthCheckPort = config.HealthCheckPort || String(port);
+    this.HealthCheckIntervalSeconds = config.HealthCheckIntervalSeconds || 30;
+    this.HealthCheckTimeoutSeconds = config.HealthCheckTimeoutSeconds || 5;
+    this.HealthyThresholdCount = config.HealthyThresholdCount || 2;
+    this.UnhealthyThresholdCount = config.UnhealthyThresholdCount || 2;
+    this.Matcher = config.Matcher || { HttpCode: '200' };
+    this.Tags = config.Tags || [];
+    this.CreatedTime = new Date().toISOString();
+    this.LoadBalancingAlgorithmType = 'round_robin';
+    this.TargetCount = 0;
+    this.HealthyCount = 0;
+    this.UnhealthyCount = 0;
+  }
+
+  registerTarget(targetId, port = null) {
+    const targetPort = port || this.Port;
+
+    // Verificar se já existe
+    if (this.Targets.some(t => t.TargetId === targetId && t.Port === targetPort)) {
+      throw new Error(`Target ${targetId}:${targetPort} already registered`);
+    }
+
+    const target = new Target(targetId, targetPort);
+    this.Targets.push(target);
+    this.updateCounts();
+    return target;
+  }
+
+  deregisterTarget(targetId, port = null) {
+    const targetPort = port || this.Port;
+    const index = this.Targets.findIndex(t => t.TargetId === targetId && t.Port === targetPort);
+
+    if (index === -1) {
+      throw new Error(`Target ${targetId}:${targetPort} not found`);
+    }
+
+    const target = this.Targets.splice(index, 1)[0];
+    this.updateCounts();
+    return target;
+  }
+
+  getNextTarget() {
+    const healthyTargets = this.Targets.filter(t => t.HealthState === 'healthy');
+    if (healthyTargets.length === 0) {
+      return null;
+    }
+    // Round robin simples
+    return healthyTargets[Math.floor(Math.random() * healthyTargets.length)];
+  }
+
+  updateCounts() {
+    this.TargetCount = this.Targets.length;
+    this.HealthyCount = this.Targets.filter(t => t.HealthState === 'healthy').length;
+    this.UnhealthyCount = this.Targets.filter(t => t.HealthState === 'unhealthy').length;
+  }
+
+  toJSON() {
+    return {
+      TargetGroupArn: this.TargetGroupArn,
+      TargetGroupName: this.TargetGroupName,
+      Protocol: this.Protocol,
+      Port: this.Port,
+      VpcId: this.VpcId,
+      TargetType: this.TargetType,
+      TargetCount: this.TargetCount,
+      HealthyCount: this.HealthyCount,
+      UnhealthyCount: this.UnhealthyCount,
+      HealthCheckEnabled: this.HealthCheckEnabled,
+      HealthCheckProtocol: this.HealthCheckProtocol,
+      HealthCheckPath: this.HealthCheckPath,
+      CreatedTime: this.CreatedTime,
+      LoadBalancingAlgorithmType: this.LoadBalancingAlgorithmType,
+      Targets: this.Targets.map(t => t.toJSON())
+    };
+  }
+}
+
+module.exports = { TargetGroup, Target };

package/src/services/alb/server.js

@@ -0,0 +1,160 @@
+/**
+ * ALB Server - API REST para Application Load Balancer
+ */
+
+const express = require('express');
+const logger = require('../../utils/logger');
+
+class ALBServer {
+  constructor(port, config) {
+    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(`ALB Request: ${req.method} ${req.path}`);
+      next();
+    });
+  }
+
+  async initialize() {
+    logger.debug(`Inicializando ALB Server na porta ${this.port}`);
+    this.setupMiddlewares();
+    this.setupRoutes();
+  }
+
+  setupRoutes() {
+    // Create Load Balancer
+    this.app.post('/__admin/alb/load-balancers/create', (req, res) => {
+      try {
+        const { Name, Scheme = 'internet-facing', ...config } = req.body;
+        if (!Name) return res.status(400).json({ error: 'Name is required' });
+
+        const alb = this.simulator.createLoadBalancer(Name, Scheme, config);
+        res.json({ LoadBalancer: alb.toJSON() });
+      } catch (error) {
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Describe Load Balancers
+    this.app.get('/__admin/alb/load-balancers', (req, res) => {
+      try {
+        const albs = this.simulator.describeLoadBalancers();
+        res.json({ LoadBalancers: albs.map(a => a.toJSON()) });
+      } catch (error) {
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Get Load Balancer
+    this.app.get('/__admin/alb/load-balancers/:albArn', (req, res) => {
+      try {
+        const alb = this.simulator.getLoadBalancer(req.params.albArn);
+        res.json({ LoadBalancer: alb.toJSON() });
+      } catch (error) {
+        res.status(404).json({ error: error.message });
+      }
+    });
+
+    // Delete Load Balancer
+    this.app.delete('/__admin/alb/load-balancers/:albArn', (req, res) => {
+      try {
+        this.simulator.deleteLoadBalancer(req.params.albArn);
+        res.json({ success: true });
+      } catch (error) {
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Create Target Group
+    this.app.post('/__admin/alb/target-groups/create', (req, res) => {
+      try {
+        const { Name, Protocol = 'HTTP', Port = 80, VpcId = null, ...config } = req.body;
+        if (!Name) return res.status(400).json({ error: 'Name is required' });
+
+        const tg = this.simulator.createTargetGroup(Name, Protocol, Port, VpcId, config);
+        res.json({ TargetGroup: tg.toJSON() });
+      } catch (error) {
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Describe Target Groups
+    this.app.get('/__admin/alb/target-groups', (req, res) => {
+      try {
+        const tgs = this.simulator.describeTargetGroups();
+        res.json({ TargetGroups: tgs.map(t => t.toJSON()) });
+      } catch (error) {
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Register Target
+    this.app.post('/__admin/alb/target-groups/:tgArn/register-target', (req, res) => {
+      try {
+        const { TargetId, Port } = req.body;
+        if (!TargetId) return res.status(400).json({ error: 'TargetId is required' });
+
+        const target = this.simulator.registerTarget(req.params.tgArn, TargetId, Port);
+        res.json({ Target: target.toJSON() });
+      } catch (error) {
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Describe Target Health
+    this.app.get('/__admin/alb/target-groups/:tgArn/health', (req, res) => {
+      try {
+        const health = this.simulator.describeTargetHealth(req.params.tgArn);
+        res.json(health);
+      } catch (error) {
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Health Check
+    this.app.get('/__admin/alb/health', (req, res) => {
+      res.json({ status: 'ok', service: 'alb' });
+    });
+
+    // Get All Resources
+    this.app.get('/__admin/alb/resources', (req, res) => {
+      try {
+        const resources = this.simulator.getAllResources();
+        res.json({
+          loadBalancers: resources.loadBalancers.map(a => a.toJSON()),
+          targetGroups: resources.targetGroups.map(t => t.toJSON())
+        });
+      } catch (error) {
+        res.status(400).json({ error: error.message });
+      }
+    });
+  }
+
+  async start() {
+    return new Promise((resolve) => {
+      this.server = this.app.listen(this.port, () => {
+        logger.info(`ALB Server running on http://localhost:${this.port}`);
+        resolve();
+      });
+    });
+  }
+
+  async stop() {
+    if (this.server) {
+      return new Promise((resolve) => {
+        this.server.close(() => {
+          logger.info('ALB Server stopped');
+          resolve();
+        });
+      });
+    }
+  }
+}
+
+module.exports = ALBServer;