@gugananuvem/aws-local-simulator 1.0.35 → 1.0.39

package/src/services/route53/index.js

@@ -0,0 +1,67 @@
+/**
+ * Route53 Service
+ */
+
+const Route53Simulator = require('./simulator');
+const Route53Server = require('./server');
+const logger = require('../../utils/logger');
+
+class Route53Service {
+  constructor(config = {}) {
+    this.name = 'route53';
+    this.config = config;
+    this.simulator = null;
+    this.server = null;
+  }
+
+  async initialize() {
+    this.simulator = new Route53Simulator(this.config);
+    await this.simulator.initialize();
+  }
+
+  injectDependencies(server) {
+    // Para possíveis integrações futuras
+  }
+
+  async start() {
+    try {
+      const port = this.config.port || 4024;
+      this.server = new Route53Server(port, this.config);
+      await this.server.initialize(this.simulator);
+      await this.server.start();
+      return true;
+    } catch (error) {
+      logger.error(`Route53 Service error: ${error.message}`);
+      throw error;
+    }
+  }
+
+  async stop() {
+    if (this.server) {
+      await this.server.stop();
+    }
+    if (this.simulator) {
+      this.simulator.stopHealthCheckInterval();
+    }
+  }
+
+  getStatus() {
+    return {
+      name: 'route53',
+      port: this.config.port || 4024,
+      running: this.server ? true : false,
+      endpoint: `http://localhost:${this.config.port || 4024}`,
+    };
+  }
+
+  async reset() {
+    if (this.simulator) {
+      this.simulator.hostedZones.clear();
+      this.simulator.resourceRecords.clear();
+      this.simulator.healthChecks.clear();
+      this.simulator.persistData();
+    }
+  }
+}
+
+module.exports = Route53Service;

package/src/services/route53/models/healthCheck.js

@@ -0,0 +1,101 @@
+/**
+ * Route53 Health Check Model
+ * Supports HTTP, HTTPS, TCP, and calculated health checks
+ */
+
+class HealthCheck {
+  constructor(config = {}) {
+    this.Id = this.generateHealthCheckId();
+    this.Type = config.Type || 'HTTP'; // HTTP, HTTPS, TCP, CALCULATED
+    this.Protocol = config.Protocol || 'HTTP';
+    this.IPAddress = config.IPAddress || '127.0.0.1';
+    this.Port = config.Port || 80;
+    this.ResourcePath = config.ResourcePath || '/';
+    this.FullyQualifiedDomainName = config.FullyQualifiedDomainName || 'localhost';
+    this.RequestInterval = config.RequestInterval || 30;
+    this.FailureThreshold = config.FailureThreshold || 3;
+    this.Enabled = config.Enabled !== false;
+    this.Status = 'Healthy'; // Healthy, Unhealthy
+    this.LastStatusChangeTime = new Date().toISOString();
+    this.CreatedDate = new Date().toISOString();
+    this.MeasureLatency = config.MeasureLatency || false;
+    this.HealthThreshold = config.HealthThreshold || 1;
+    this.ChildHealthChecks = config.ChildHealthChecks || [];
+    this.FailedChecks = 0;
+    this.LastCheckResult = {
+      status: 'Success',
+      timestamp: new Date().toISOString(),
+      latency: Math.random() * 100, // 0-100ms
+    };
+  }
+
+  generateHealthCheckId() {
+    const chars = '0123456789abcdef';
+    let id = '';
+    for (let i = 0; i < 32; i++) {
+      id += chars.charAt(Math.floor(Math.random() * 16));
+    }
+    return id;
+  }
+
+  /**
+   * Simulate health check
+   */
+  check() {
+    if (!this.Enabled) {
+      this.Status = 'Disabled';
+      return false;
+    }
+
+    // Simulate health check with 95% success rate
+    const isHealthy = Math.random() > 0.05;
+
+    if (isHealthy) {
+      this.FailedChecks = 0;
+      if (this.Status !== 'Healthy') {
+        this.Status = 'Healthy';
+        this.LastStatusChangeTime = new Date().toISOString();
+      }
+    } else {
+      this.FailedChecks++;
+      if (this.FailedChecks >= this.FailureThreshold) {
+        this.Status = 'Unhealthy';
+        this.LastStatusChangeTime = new Date().toISOString();
+      }
+    }
+
+    this.LastCheckResult = {
+      status: isHealthy ? 'Success' : 'Failed',
+      timestamp: new Date().toISOString(),
+      latency: Math.random() * 100,
+    };
+
+    return isHealthy;
+  }
+
+  toJSON() {
+    return {
+      Id: this.Id,
+      Type: this.Type,
+      HealthCheckConfig: {
+        Type: this.Type,
+        Protocol: this.Protocol,
+        IPAddress: this.IPAddress,
+        Port: this.Port,
+        ResourcePath: this.ResourcePath,
+        FullyQualifiedDomainName: this.FullyQualifiedDomainName,
+        RequestInterval: this.RequestInterval,
+        FailureThreshold: this.FailureThreshold,
+        MeasureLatency: this.MeasureLatency,
+        HealthThreshold: this.HealthThreshold,
+      },
+      HealthCheckObservations: {
+        Status: this.Status,
+        LastStatusChangeTime: this.LastStatusChangeTime,
+        LastCheckResult: this.LastCheckResult,
+      },
+    };
+  }
+}
+
+module.exports = HealthCheck;

package/src/services/route53/models/hostedZone.js

@@ -0,0 +1,37 @@
+/**
+ * Route53 Hosted Zone Model
+ */
+
+class HostedZone {
+  constructor(name, config = {}) {
+    this.Id = this.generateHostedZoneId();
+    this.Name = name;
+    this.Config = config || {};
+    this.ResourceRecordSetCount = 0;
+    this.CallerReference = config.CallerReference || new Date().getTime().toString();
+    this.HostedZoneConfig = {
+      Comment: config.Comment || '',
+      PrivateZone: config.PrivateZone || false,
+    };
+    this.CreatedDate = new Date().toISOString();
+  }
+
+  generateHostedZoneId() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 15);
+    return `/hostedzone/${random}${timestamp}`.substring(0, 30);
+  }
+
+  toJSON() {
+    return {
+      Id: this.Id,
+      Name: this.Name,
+      CallerReference: this.CallerReference,
+      Config: this.HostedZoneConfig,
+      ResourceRecordSetCount: this.ResourceRecordSetCount,
+      CreatedDate: this.CreatedDate,
+    };
+  }
+}
+
+module.exports = HostedZone;

package/src/services/route53/models/resourceRecord.js

@@ -0,0 +1,106 @@
+/**
+ * Route53 Resource Record Model
+ * Supports weighted routing, health checks, and multiple record types
+ */
+
+class ResourceRecord {
+  constructor(name, type, values, config = {}) {
+    this.Name = name;
+    this.Type = type;
+    this.TTL = config.TTL || 300;
+    this.SetIdentifier = config.SetIdentifier || null;
+    this.Weight = config.Weight || null;
+    this.Region = config.Region || null;
+    this.GeoLocation = config.GeoLocation || null;
+    this.MultiValueAnswer = config.MultiValueAnswer || false;
+    this.HealthCheckId = config.HealthCheckId || null;
+    this.Failover = config.Failover || null; // PRIMARY or SECONDARY
+    this.ResourceRecords = Array.isArray(values) ? values.map(v => ({ Value: v })) : [{ Value: values }];
+    this.CreatedDate = new Date().toISOString();
+    this.LastModified = this.CreatedDate;
+  }
+
+  toJSON() {
+    const record = {
+      Name: this.Name,
+      Type: this.Type,
+      TTL: this.TTL,
+      ResourceRecords: this.ResourceRecords,
+    };
+
+    if (this.SetIdentifier) record.SetIdentifier = this.SetIdentifier;
+    if (this.Weight) record.Weight = this.Weight;
+    if (this.Region) record.Region = this.Region;
+    if (this.GeoLocation) record.GeoLocation = this.GeoLocation;
+    if (this.MultiValueAnswer) record.MultiValueAnswer = this.MultiValueAnswer;
+    if (this.HealthCheckId) record.HealthCheckId = this.HealthCheckId;
+    if (this.Failover) record.Failover = this.Failover;
+
+    return record;
+  }
+
+  /**
+   * Resolve records based on weights (weighted routing)
+   */
+  static selectWeightedRecords(records) {
+    // Filter only weighted records
+    const weightedRecords = records.filter(r => r.Weight !== null && r.Weight !== undefined);
+    
+    if (weightedRecords.length === 0) {
+      return records.filter(r => !r.SetIdentifier); // Return non-weighted records
+    }
+
+    const totalWeight = weightedRecords.reduce((sum, r) => sum + r.Weight, 0);
+    const random = Math.random() * totalWeight;
+
+    let accumulated = 0;
+    for (const record of weightedRecords) {
+      accumulated += record.Weight;
+      if (random <= accumulated) {
+        return [record];
+      }
+    }
+
+    return [weightedRecords[0]]; // Fallback to first
+  }
+
+  /**
+   * Resolve records based on geolocation
+   */
+  static selectGeoLocationRecords(records, country = 'US') {
+    // Filter geo-located records
+    const geoRecords = records.filter(r => r.GeoLocation);
+    
+    if (geoRecords.length === 0) {
+      return records.filter(r => !r.SetIdentifier);
+    }
+
+    const matched = geoRecords.find(r => 
+      r.GeoLocation.CountryCode === country || 
+      r.GeoLocation.CountryCode === '*'
+    );
+
+    return matched ? [matched] : [geoRecords[0]];
+  }
+
+  /**
+   * Resolve records based on failover policy
+   */
+  static selectFailoverRecords(records, healthyIds = []) {
+    const primary = records.find(r => r.Failover === 'PRIMARY');
+    const secondary = records.find(r => r.Failover === 'SECONDARY');
+
+    if (!primary) return [records[0]];
+
+    // Check if primary is healthy
+    const primaryHealthy = !primary.HealthCheckId || healthyIds.includes(primary.HealthCheckId);
+
+    if (primaryHealthy) {
+      return [primary];
+    }
+
+    return secondary ? [secondary] : [primary];
+  }
+}
+
+module.exports = ResourceRecord;