@gugananuvem/aws-local-simulator 1.0.34 → 1.0.39

package/src/services/asg/index.js

@@ -0,0 +1,100 @@
+/**
+ * ASG Service - Ponto de entrada
+ */
+
+const ASGServer = require('./server');
+const ASGSimulator = require('./simulator');
+
+class ASGService {
+  constructor(config) {
+    this.config = config;
+    this.name = 'asg';
+    this.port = config.ports.asg || 4022;
+    this.server = null;
+    this.simulator = null;
+    this.isRunning = false;
+  }
+
+  async initialize() {
+    const logger = require('../../utils/logger');
+    logger.debug(`Inicializando ASG Service na porta ${this.port}...`);
+
+    this.simulator = new ASGSimulator(this.config.asg || {});
+    await this.simulator.initialize();
+
+    this.server = new ASGServer(this.port, this.config);
+    this.server.simulator = this.simulator;
+
+    await this.server.initialize();
+
+    logger.debug('ASG Service inicializado');
+  }
+
+  injectDependencies(ec2Service, albService) {
+    // Injetar dependências para que o ASG possa criar/terminar instâncias
+    this.simulator.injectDependencies(ec2Service, albService);
+  }
+
+  async start() {
+    const logger = require('../../utils/logger');
+
+    if (this.isRunning) {
+      logger.warn('ASG Service já está em execução');
+      return;
+    }
+
+    try {
+      await this.server.start();
+      this.isRunning = true;
+      logger.info('ASG Service iniciado com sucesso');
+    } catch (error) {
+      logger.error(`Erro ao iniciar ASG Service: ${error.message}`);
+      throw error;
+    }
+  }
+
+  async stop() {
+    const logger = require('../../utils/logger');
+
+    if (!this.isRunning) {
+      logger.warn('ASG Service não está em execução');
+      return;
+    }
+
+    try {
+      await this.server.stop();
+      this.isRunning = false;
+      logger.info('ASG Service parado com sucesso');
+    } catch (error) {
+      logger.error(`Erro ao parar ASG Service: ${error.message}`);
+      throw error;
+    }
+  }
+
+  getSimulator() {
+    return this.simulator;
+  }
+
+  getStatus() {
+    const resources = this.simulator.getAllResources();
+    const totalInstances = resources.autoScalingGroups.reduce(
+      (sum, asg) => sum + asg.Instances.length,
+      0
+    );
+
+    return {
+      name: this.name,
+      running: this.isRunning,
+      port: this.port,
+      endpoint: `http://localhost:${this.port}`,
+      resources: {
+        autoScalingGroupsCount: resources.autoScalingGroups.length,
+        launchTemplatesCount: resources.launchTemplates.length,
+        scalingPoliciesCount: resources.scalingPolicies.length,
+        totalInstances: totalInstances
+      }
+    };
+  }
+}
+
+module.exports = ASGService;

package/src/services/asg/models/autoScalingGroup.js

@@ -0,0 +1,110 @@
+/**
+ * Auto Scaling Group Model
+ */
+
+const { v4: uuid } = require('uuid');
+
+class AutoScalingGroup {
+  constructor(name, launchTemplate, config = {}) {
+    this.AutoScalingGroupName = name;
+    this.AutoScalingGroupARN = `arn:aws:autoscaling:us-east-1:123456789012:autoScalingGroup:${uuid()}:autoScalingGroupName/${name}`;
+    
+    // Launch Configuration
+    this.LaunchTemplate = launchTemplate;
+    
+    // Capacity
+    this.MinSize = config.minSize || 1;
+    this.MaxSize = config.maxSize || 5;
+    this.DesiredCapacity = config.desiredCapacity || this.MinSize;
+    this.Instances = []; // Array de instanceIds gerenciados por esse ASG
+    
+    // Subnets
+    this.VPCZoneIdentifier = config.vpcZoneIdentifier || [];
+    this.AvailabilityZones = config.availabilityZones || ['us-east-1a'];
+    
+    // Target Groups (para ALB)
+    this.TargetGroupARNs = config.targetGroupARNs || [];
+    this.LoadBalancerNames = config.loadBalancerNames || [];
+    
+    // Policies
+    this.HealthCheckType = config.healthCheckType || 'ELB';
+    this.HealthCheckGracePeriod = config.healthCheckGracePeriod || 300;
+    
+    // Tags
+    this.Tags = config.tags || [];
+    
+    // Scaling & Lifecycle
+    this.SuspendedProcesses = [];
+    this.EnabledMetrics = config.enabledMetrics || ['GroupInServiceInstances', 'GroupTerminatingInstances'];
+    this.CreationTime = new Date();
+    this.Status = 'Active';
+    
+    // Internal tracking
+    this.lastScalingTime = new Date();
+    this.scalingPolicies = [];
+  }
+
+  toJSON() {
+    return {
+      AutoScalingGroupName: this.AutoScalingGroupName,
+      AutoScalingGroupARN: this.AutoScalingGroupARN,
+      LaunchTemplate: this.LaunchTemplate.toJSON(),
+      MinSize: this.MinSize,
+      MaxSize: this.MaxSize,
+      DesiredCapacity: this.DesiredCapacity,
+      Instances: this.Instances.map(inst => ({
+        InstanceId: inst.InstanceId,
+        InstanceType: inst.InstanceType,
+        AvailabilityZone: inst.AvailabilityZone,
+        LifecycleState: inst.LifecycleState,
+        HealthStatus: inst.HealthStatus
+      })),
+      VPCZoneIdentifier: this.VPCZoneIdentifier,
+      AvailabilityZones: this.AvailabilityZones,
+      TargetGroupARNs: this.TargetGroupARNs,
+      LoadBalancerNames: this.LoadBalancerNames,
+      HealthCheckType: this.HealthCheckType,
+      HealthCheckGracePeriod: this.HealthCheckGracePeriod,
+      Tags: this.Tags,
+      EnabledMetrics: this.EnabledMetrics,
+      CreationTime: this.CreationTime,
+      Status: this.Status
+    };
+  }
+
+  addInstance(instance) {
+    this.Instances.push({
+      InstanceId: instance.InstanceId,
+      InstanceType: instance.InstanceType,
+      AvailabilityZone: this.AvailabilityZones[0],
+      LifecycleState: 'InService',
+      HealthStatus: 'Healthy'
+    });
+  }
+
+  removeInstance(instanceId) {
+    this.Instances = this.Instances.filter(inst => inst.InstanceId !== instanceId);
+  }
+
+  getInstanceCount() {
+    return this.Instances.length;
+  }
+
+  canScaleUp() {
+    return this.getInstanceCount() < this.MaxSize;
+  }
+
+  canScaleDown() {
+    return this.getInstanceCount() > this.MinSize;
+  }
+
+  isBelowDesiredCapacity() {
+    return this.getInstanceCount() < this.DesiredCapacity;
+  }
+
+  isAboveDesiredCapacity() {
+    return this.getInstanceCount() > this.DesiredCapacity;
+  }
+}
+
+module.exports = AutoScalingGroup;

package/src/services/asg/models/launchTemplate.js

@@ -0,0 +1,41 @@
+/**
+ * Launch Template Model - Template de configuração para ASG
+ */
+
+const { v4: uuid } = require('uuid');
+
+class LaunchTemplate {
+  constructor(name, imageId, instanceType, config = {}) {
+    this.LaunchTemplateId = uuid();
+    this.LaunchTemplateName = name;
+    this.ImageId = imageId;
+    this.InstanceType = instanceType;
+    this.KeyName = config.keyName || null;
+    this.SecurityGroupIds = config.securityGroupIds || [];
+    this.UserData = config.userData || null;
+    this.IamInstanceProfile = config.iamInstanceProfile || null;
+    this.Monitoring = config.monitoring || { Enabled: false };
+    this.TagSpecifications = config.tagSpecifications || [];
+    this.CreationTime = new Date();
+    this.VersionNumber = 1;
+  }
+
+  toJSON() {
+    return {
+      LaunchTemplateId: this.LaunchTemplateId,
+      LaunchTemplateName: this.LaunchTemplateName,
+      ImageId: this.ImageId,
+      InstanceType: this.InstanceType,
+      KeyName: this.KeyName,
+      SecurityGroupIds: this.SecurityGroupIds,
+      UserData: this.UserData,
+      IamInstanceProfile: this.IamInstanceProfile,
+      Monitoring: this.Monitoring,
+      TagSpecifications: this.TagSpecifications,
+      CreationTime: this.CreationTime,
+      VersionNumber: this.VersionNumber
+    };
+  }
+}
+
+module.exports = LaunchTemplate;

package/src/services/asg/models/scalingPolicy.js

@@ -0,0 +1,51 @@
+/**
+ * Scaling Policy Model - Política de escalamento automático
+ */
+
+const { v4: uuid } = require('uuid');
+
+class ScalingPolicy {
+  constructor(name, asgName, policyType, config = {}) {
+    this.PolicyName = name;
+    this.AutoScalingGroupName = asgName;
+    this.PolicyARN = `arn:aws:autoscaling:us-east-1:123456789012:scalingPolicy:${uuid()}:autoScalingGroupName/${asgName}:policyName/${name}`;
+    this.PolicyType = policyType; // 'TargetTrackingScaling', 'StepScaling', 'SimpleScaling'
+    
+    // Target Tracking
+    this.TargetValue = config.targetValue || null;
+    this.PredefinedMetricSpecification = config.predefinedMetricSpecification || {
+      PredefinedMetricType: 'ASGAverageCPUUtilization'
+    };
+    this.ScaleOutCooldown = config.scaleOutCooldown || 300;
+    this.ScaleInCooldown = config.scaleInCooldown || 300;
+
+    // Step Scaling
+    this.AdjustmentType = config.adjustmentType || 'ChangeInCapacity';
+    this.MetricAggregationType = config.metricAggregationType || 'Average';
+    this.StepAdjustments = config.stepAdjustments || [];
+
+    // Common
+    this.Enabled = config.enabled !== false;
+    this.CreationTime = new Date();
+  }
+
+  toJSON() {
+    return {
+      PolicyName: this.PolicyName,
+      AutoScalingGroupName: this.AutoScalingGroupName,
+      PolicyARN: this.PolicyARN,
+      PolicyType: this.PolicyType,
+      TargetValue: this.TargetValue,
+      PredefinedMetricSpecification: this.PredefinedMetricSpecification,
+      ScaleOutCooldown: this.ScaleOutCooldown,
+      ScaleInCooldown: this.ScaleInCooldown,
+      AdjustmentType: this.AdjustmentType,
+      MetricAggregationType: this.MetricAggregationType,
+      StepAdjustments: this.StepAdjustments,
+      Enabled: this.Enabled,
+      CreationTime: this.CreationTime
+    };
+  }
+}
+
+module.exports = ScalingPolicy;

package/src/services/asg/server.js

@@ -0,0 +1,236 @@
+/**
+ * ASG Server - API REST para Auto Scaling Group
+ */
+
+const express = require('express');
+const logger = require('../../utils/logger');
+
+class ASGServer {
+  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(`ASG Request: ${req.method} ${req.path}`);
+      next();
+    });
+  }
+
+  async initialize() {
+    logger.debug(`Inicializando ASG Server na porta ${this.port}`);
+    this.setupMiddlewares();
+    this.setupRoutes();
+  }
+
+  setupRoutes() {
+    // ========== Launch Template ==========
+
+    // Create Launch Template
+    this.app.post('/__admin/asg/launch-templates/create', (req, res) => {
+      try {
+        const { Name, ImageId, InstanceType, ...config } = req.body;
+        if (!Name || !ImageId || !InstanceType) {
+          return res.status(400).json({ error: 'Name, ImageId, and InstanceType are required' });
+        }
+
+        const lt = this.simulator.createLaunchTemplate(Name, ImageId, InstanceType, config);
+        res.json({ LaunchTemplate: lt.toJSON() });
+      } catch (error) {
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Describe Launch Templates
+    this.app.get('/__admin/asg/launch-templates', (req, res) => {
+      try {
+        const lts = this.simulator.describeLaunchTemplates();
+        res.json({ LaunchTemplates: lts.map(lt => lt.toJSON()) });
+      } catch (error) {
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Get Launch Template
+    this.app.get('/__admin/asg/launch-templates/:templateId', (req, res) => {
+      try {
+        const lt = this.simulator.getLaunchTemplate(req.params.templateId);
+        res.json({ LaunchTemplate: lt.toJSON() });
+      } catch (error) {
+        res.status(404).json({ error: error.message });
+      }
+    });
+
+    // Delete Launch Template
+    this.app.delete('/__admin/asg/launch-templates/:templateId', (req, res) => {
+      try {
+        this.simulator.deleteLaunchTemplate(req.params.templateId);
+        res.json({ success: true });
+      } catch (error) {
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // ========== Auto Scaling Group ==========
+
+    // Create Auto Scaling Group
+    this.app.post('/__admin/asg/auto-scaling-groups/create', (req, res) => {
+      try {
+        const { AutoScalingGroupName, LaunchTemplateId, ...config } = req.body;
+        if (!AutoScalingGroupName || !LaunchTemplateId) {
+          return res.status(400).json({
+            error: 'AutoScalingGroupName and LaunchTemplateId are required'
+          });
+        }
+
+        const asg = this.simulator.createAutoScalingGroup(AutoScalingGroupName, LaunchTemplateId, config);
+        res.json({ AutoScalingGroup: asg.toJSON() });
+      } catch (error) {
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Describe Auto Scaling Groups
+    this.app.get('/__admin/asg/auto-scaling-groups', (req, res) => {
+      try {
+        const asgs = this.simulator.describeAutoScalingGroups();
+        res.json({ AutoScalingGroups: asgs.map(asg => asg.toJSON()) });
+      } catch (error) {
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Get Auto Scaling Group
+    this.app.get('/__admin/asg/auto-scaling-groups/:name', (req, res) => {
+      try {
+        const asg = this.simulator.getAutoScalingGroup(req.params.name);
+        res.json({ AutoScalingGroup: asg.toJSON() });
+      } catch (error) {
+        res.status(404).json({ error: error.message });
+      }
+    });
+
+    // Delete Auto Scaling Group
+    this.app.delete('/__admin/asg/auto-scaling-groups/:name', (req, res) => {
+      try {
+        const forceDelete = req.query.forceDelete === 'true';
+        this.simulator.deleteAutoScalingGroup(req.params.name, forceDelete);
+        res.json({ success: true });
+      } catch (error) {
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // ========== Scaling Operations ==========
+
+    // Set Desired Capacity
+    this.app.put('/__admin/asg/auto-scaling-groups/:name/desired-capacity', (req, res) => {
+      try {
+        const { DesiredCapacity } = req.body;
+        if (DesiredCapacity === undefined) {
+          return res.status(400).json({ error: 'DesiredCapacity is required' });
+        }
+
+        const asg = this.simulator.setDesiredCapacity(req.params.name, DesiredCapacity);
+        res.json({ AutoScalingGroup: asg.toJSON() });
+      } catch (error) {
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // ========== Scaling Policies ==========
+
+    // Attach Scaling Policy
+    this.app.post('/__admin/asg/auto-scaling-groups/:name/scaling-policies', (req, res) => {
+      try {
+        const { PolicyName, PolicyType, ...config } = req.body;
+        if (!PolicyName || !PolicyType) {
+          return res.status(400).json({ error: 'PolicyName and PolicyType are required' });
+        }
+
+        const policy = this.simulator.attachScalingPolicy(req.params.name, PolicyName, PolicyType, config);
+        res.json({ ScalingPolicy: policy.toJSON() });
+      } catch (error) {
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Describe Scaling Policies
+    this.app.get('/__admin/asg/auto-scaling-groups/:name/scaling-policies', (req, res) => {
+      try {
+        const policies = this.simulator.describeScalingPolicies(req.params.name);
+        res.json({ ScalingPolicies: policies.map(p => p.toJSON()) });
+      } catch (error) {
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Detach Scaling Policy
+    this.app.delete('/__admin/asg/auto-scaling-groups/:name/scaling-policies/:policyName', (req, res) => {
+      try {
+        this.simulator.detachScalingPolicy(req.params.name, req.params.policyName);
+        res.json({ success: true });
+      } catch (error) {
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // Evaluate Scaling Policies (manual trigger)
+    this.app.post('/__admin/asg/auto-scaling-groups/:name/evaluate-policies', (req, res) => {
+      try {
+        this.simulator.evaluateScalingPolicies(req.params.name);
+        const asg = this.simulator.getAutoScalingGroup(req.params.name);
+        res.json({ AutoScalingGroup: asg.toJSON() });
+      } catch (error) {
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    // ========== Health & Admin ==========
+
+    // Health Check
+    this.app.get('/__admin/asg/health', (req, res) => {
+      res.json({ status: 'ok', service: 'asg' });
+    });
+
+    // Get All Resources
+    this.app.get('/__admin/asg/resources', (req, res) => {
+      try {
+        const resources = this.simulator.getAllResources();
+        res.json({
+          autoScalingGroups: resources.autoScalingGroups.map(a => a.toJSON()),
+          launchTemplates: resources.launchTemplates.map(lt => lt.toJSON()),
+          scalingPolicies: resources.scalingPolicies.map(p => p.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(`ASG Server running on http://localhost:${this.port}`);
+        resolve();
+      });
+    });
+  }
+
+  async stop() {
+    if (this.server) {
+      return new Promise((resolve) => {
+        this.server.close(() => {
+          logger.info('ASG Server stopped');
+          resolve();
+        });
+      });
+    }
+  }
+}
+
+module.exports = ASGServer;