@gugananuvem/aws-local-simulator 1.0.35 → 1.0.39

package/src/services/kinesis-firehose/index.js

@@ -0,0 +1,106 @@
+/**
+ * Kinesis Data Firehose Service - Ponto de entrada
+ */
+
+const KinesisFirehoseServer = require('./server');
+const KinesisFirehoseSimulator = require('./simulator');
+
+class KinesisFirehoseService {
+  constructor(config) {
+    this.config = config;
+    this.name = 'kinesis-firehose';
+    this.port = config.ports['kinesis-firehose'] || 4569;
+    this.server = null;
+    this.simulator = null;
+    this.isRunning = false;
+  }
+
+  async initialize() {
+    const logger = require('../../utils/logger');
+    logger.debug(`Inicializando Kinesis Firehose Service na porta ${this.port}...`);
+
+    this.simulator = new KinesisFirehoseSimulator(this.config);
+    await this.simulator.initialize();
+
+    this.server = new KinesisFirehoseServer(this.port, this.config);
+    this.server.simulator = this.simulator;
+
+    await this.server.initialize();
+
+    logger.debug('Kinesis Firehose Service inicializado');
+  }
+
+  injectDependencies(server) {
+    // Aqui você pode injetar dependências de outros serviços se necessário
+  }
+
+  async start() {
+    const logger = require('../../utils/logger');
+
+    if (this.isRunning) {
+      logger.warn('Kinesis Firehose Service já está em execução');
+      return;
+    }
+
+    try {
+      await this.server.start();
+      this.isRunning = true;
+      logger.info('Kinesis Firehose Service iniciado com sucesso');
+    } catch (error) {
+      logger.error(`Erro ao iniciar Kinesis Firehose Service: ${error.message}`);
+      throw error;
+    }
+  }
+
+  async stop() {
+    const logger = require('../../utils/logger');
+
+    if (!this.isRunning) {
+      logger.warn('Kinesis Firehose Service não está em execução');
+      return;
+    }
+
+    try {
+      await this.server.stop();
+      this.isRunning = false;
+      logger.info('Kinesis Firehose Service parado com sucesso');
+    } catch (error) {
+      logger.error(`Erro ao parar Kinesis Firehose Service: ${error.message}`);
+      throw error;
+    }
+  }
+
+  async reset() {
+    const logger = require('../../utils/logger');
+    try {
+      await this.simulator.reset();
+      logger.info('Kinesis Firehose Service resetado');
+    } catch (error) {
+      logger.error(`Erro ao resetar Kinesis Firehose Service: ${error.message}`);
+      throw error;
+    }
+  }
+
+  getSimulator() {
+    return this.simulator;
+  }
+
+  getStatus() {
+    const stats = this.simulator?.getStats() || { deliveryStreamsCount: 0, totalRecords: 0, totalDeliveredRecords: 0 };
+
+    return {
+      name: this.name,
+      running: this.isRunning,
+      port: this.port,
+      endpoint: `http://localhost:${this.port}`,
+      resources: {
+        deliveryStreamsCount: stats.deliveryStreamsCount,
+        totalRecords: stats.totalRecords,
+        totalDeliveredRecords: stats.totalDeliveredRecords,
+        totalFailedRecords: stats.totalFailedRecords
+      }
+    };
+  }
+}
+
+module.exports = KinesisFirehoseService;

package/src/services/kinesis-firehose/models/delivery-stream.js

@@ -0,0 +1,265 @@
+/**
+ * Kinesis Data Firehose - DeliveryStream Model
+ * Representa um stream de entrega (delivery stream)
+ */
+
+const { v4: uuidv4 } = require('uuid');
+
+class DeliveryStream {
+  constructor(deliveryStreamName, config = {}) {
+    this.deliveryStreamName = deliveryStreamName;
+    this.deliveryStreamArn = `arn:aws:firehose:us-east-1:123456789012:deliverystream/${deliveryStreamName}`;
+    this.deliveryStreamStatus = 'ACTIVE';
+    this.deliveryStreamType = config.deliveryStreamType || 'DirectPut';
+    this.deliveryStreamCreationTimestamp = new Date().toISOString();
+    this.lastUpdateTimestamp = new Date().toISOString();
+
+    // Fonte de dados (pode ser Kinesis Data Stream)
+    this.sourceDescription = config.sourceDescription || null;
+
+    // Destinos (S3, HTTP, Redshift, etc)
+    this.destinations = [];
+    this.failedDestinationCount = 0;
+
+    // Configurações de destino
+    this.s3DestinationDescription = config.s3DestinationDescription || null;
+    this.httpDestinationDescription = config.httpDestinationDescription || null;
+    this.redshiftDestinationDescription = config.redshiftDestinationDescription || null;
+
+    // Versão
+    this.versionId = config.versionId || '1';
+
+    // Buffer de entrega
+    this.deliveryBuffer = new DeliveryBuffer();
+
+    // Estatísticas
+    this.recordCount = 0;
+    this.deliveredRecordCount = 0;
+    this.failedDeliveryRecordCount = 0;
+    this.incomingRecords = 0;
+    this.incomingBytes = 0;
+    this.deliveredBytes = 0;
+
+    // Tags
+    this.tags = config.tags || {};
+  }
+
+  /**
+   * Adiciona destino
+   */
+  addDestination(destination) {
+    this.destinations.push(destination);
+    if (destination.type === 's3') {
+      this.s3DestinationDescription = destination;
+    } else if (destination.type === 'http') {
+      this.httpDestinationDescription = destination;
+    } else if (destination.type === 'redshift') {
+      this.redshiftDestinationDescription = destination;
+    }
+    this.lastUpdateTimestamp = new Date().toISOString();
+  }
+
+  /**
+   * Obtém primeira destination
+   */
+  getFirstDestination() {
+    return this.destinations[0] || null;
+  }
+
+  /**
+   * Adiciona record ao buffer
+   */
+  addRecordToBuffer(recordData) {
+    if (!recordData) {
+      throw new Error('recordData is required');
+    }
+
+    const record = {
+      recordId: uuidv4(),
+      data: recordData,
+      timestamp: new Date().toISOString(),
+      deliveryAttempts: 0,
+      deliveryStatus: 'PENDING'
+    };
+
+    this.deliveryBuffer.addRecord(record);
+    this.recordCount++;
+    this.incomingRecords++;
+    
+    // Calcula tamanho do record
+    try {
+      const dataStr = typeof recordData === 'string' ? recordData : JSON.stringify(recordData);
+      this.incomingBytes += Buffer.byteLength(dataStr);
+    } catch (e) {
+      // Fallback para tamanho aproximado se conversão falhar
+      this.incomingBytes += 100;
+    }
+
+    return record;
+  }
+
+  /**
+   * Obtém records pendentes do buffer
+   */
+  getPendingRecords(limit = 500) {
+    return this.deliveryBuffer.getPendingRecords(limit);
+  }
+
+  /**
+   * Marca record como entregue
+   */
+  markRecordAsDelivered(recordId) {
+    const record = this.deliveryBuffer.getRecord(recordId);
+    if (record) {
+      record.deliveryStatus = 'DELIVERED';
+      this.deliveredRecordCount++;
+      this.deliveredBytes += Buffer.byteLength(JSON.stringify(record.data));
+      this.lastUpdateTimestamp = new Date().toISOString();
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Marca record como falha de entrega
+   */
+  markRecordAsFailed(recordId) {
+    const record = this.deliveryBuffer.getRecord(recordId);
+    if (record) {
+      record.deliveryAttempts++;
+      record.deliveryStatus = 'FAILED';
+      this.failedDeliveryRecordCount++;
+      this.lastUpdateTimestamp = new Date().toISOString();
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Retorna descrição do delivery stream
+   */
+  describe() {
+    return {
+      DeliveryStreamDescription: {
+        DeliveryStreamName: this.deliveryStreamName,
+        DeliveryStreamArn: this.deliveryStreamArn,
+        DeliveryStreamStatus: this.deliveryStreamStatus,
+        DeliveryStreamType: this.deliveryStreamType,
+        VersionId: this.versionId,
+        CreationTimestamp: this.deliveryStreamCreationTimestamp,
+        LastUpdateTimestamp: this.lastUpdateTimestamp,
+        Source: this.sourceDescription,
+        Destinations: this.destinations.map(d => ({
+          DestinationId: d.destinationId || 'destination-1',
+          DestinationStatus: d.destinationStatus || 'ACTIVE',
+          S3DestinationDescription: d.type === 's3' ? d : undefined,
+          HttpEndpointDestinationDescription: d.type === 'http' ? d : undefined,
+          RedshiftDestinationDescription: d.type === 'redshift' ? d : undefined
+        })),
+        HasMoreDestinations: false,
+        FailureDescription: null
+      }
+    };
+  }
+
+  toJSON() {
+    return {
+      deliveryStreamName: this.deliveryStreamName,
+      deliveryStreamArn: this.deliveryStreamArn,
+      deliveryStreamStatus: this.deliveryStreamStatus,
+      deliveryStreamType: this.deliveryStreamType,
+      creationTimestamp: this.deliveryStreamCreationTimestamp,
+      lastUpdateTimestamp: this.lastUpdateTimestamp,
+      recordCount: this.recordCount,
+      deliveredRecordCount: this.deliveredRecordCount,
+      failedDeliveryRecordCount: this.failedDeliveryRecordCount,
+      incomingRecords: this.incomingRecords,
+      incomingBytes: this.incomingBytes,
+      deliveredBytes: this.deliveredBytes
+    };
+  }
+}
+
+/**
+ * DeliveryBuffer Model - Buffer de records a serem entregues
+ */
+class DeliveryBuffer {
+  constructor(config = {}) {
+    this.bufferSizeMB = config.bufferSizeMB || 128;
+    this.bufferIntervalSeconds = config.bufferIntervalSeconds || 60;
+    this.records = new Map();
+    this.createdAt = new Date();
+    this.lastFlushTime = new Date();
+  }
+
+  /**
+   * Adiciona record ao buffer
+   */
+  addRecord(record) {
+    this.records.set(record.recordId, record);
+  }
+
+  /**
+   * Obtém record
+   */
+  getRecord(recordId) {
+    return this.records.get(recordId);
+  }
+
+  /**
+   * Obtém records pendentes
+   */
+  getPendingRecords(limit = 500) {
+    const pending = Array.from(this.records.values())
+      .filter(r => r.deliveryStatus === 'PENDING')
+      .slice(0, limit);
+    return pending;
+  }
+
+  /**
+   * Obtém todos os records
+   */
+  getAllRecords() {
+    return Array.from(this.records.values());
+  }
+
+  /**
+   * Remove record
+   */
+  removeRecord(recordId) {
+    return this.records.delete(recordId);
+  }
+
+  /**
+   * Limpa buffer (para reset)
+   */
+  clear() {
+    this.records.clear();
+    this.createdAt = new Date();
+    this.lastFlushTime = new Date();
+  }
+
+  /**
+   * Obtém estatísticas do buffer
+   */
+  getStats() {
+    const records = Array.from(this.records.values());
+    const totalRecords = records.length;
+    const pendingRecords = records.filter(r => r.deliveryStatus === 'PENDING').length;
+    const deliveredRecords = records.filter(r => r.deliveryStatus === 'DELIVERED').length;
+    const failedRecords = records.filter(r => r.deliveryStatus === 'FAILED').length;
+
+    return {
+      totalRecords,
+      pendingRecords,
+      deliveredRecords,
+      failedRecords,
+      bufferAge: Date.now() - this.createdAt.getTime()
+    };
+  }
+}
+
+module.exports = {
+  DeliveryStream,
+  DeliveryBuffer
+};

package/src/services/kinesis-firehose/models/index.js

@@ -0,0 +1,10 @@
+/**
+ * Kinesis Data Firehose Models
+ */
+
+const { DeliveryStream, DeliveryBuffer } = require('./delivery-stream');
+
+module.exports = {
+  DeliveryStream,
+  DeliveryBuffer
+};

package/src/services/kinesis-firehose/server.js

@@ -0,0 +1,215 @@
+/**
+ * Kinesis Data Firehose Server - Servidor HTTP REST/JSON para Firehose
+ */
+
+const express = require('express');
+const cors = require('cors');
+const logger = require('../../utils/logger');
+
+class KinesisFirehoseServer {
+  constructor(port, config) {
+    this.port = port;
+    this.config = config;
+    this.app = express();
+    this.simulator = null;
+    this.server = null;
+    this.setupMiddlewares();
+  }
+
+  setupMiddlewares() {
+    this.app.use(cors());
+    this.app.use(express.json({ limit: '10mb' }));
+
+    // Custom header parsing para AWS SDK
+    this.app.use((req, res, next) => {
+      const target = req.headers['x-amz-target'];
+      if (target) {
+        const [, action] = target.split('.');
+        req.action = action;
+      }
+
+      logger.debug(`Kinesis Firehose: ${req.method} ${req.path} - Action: ${req.action || 'none'}`);
+      next();
+    });
+  }
+
+  async initialize() {
+    logger.debug(`Inicializando Kinesis Firehose Server na porta ${this.port}`);
+    this.setupRoutes();
+  }
+
+  setupRoutes() {
+    this.app.post('/', (req, res) => {
+      const action = req.action || req.body.Action;
+
+      try {
+        switch (action) {
+          case 'CreateDeliveryStream':
+            return this.createDeliveryStream(req, res);
+          case 'DescribeDeliveryStream':
+            return this.describeDeliveryStream(req, res);
+          case 'ListDeliveryStreams':
+            return this.listDeliveryStreams(req, res);
+          case 'DeleteDeliveryStream':
+            return this.deleteDeliveryStream(req, res);
+          case 'PutRecord':
+            return this.putRecord(req, res);
+          case 'PutRecordBatch':
+            return this.putRecordBatch(req, res);
+          case 'UpdateDeliveryStream':
+            return this.updateDeliveryStream(req, res);
+          case 'DescribeDestination':
+            return this.describeDestination(req, res);
+          default:
+            res.status(400).json({ __type: 'UnknownAction', message: `Unknown action: ${action}` });
+        }
+      } catch (error) {
+        res.status(400).json({ __type: 'InternalFailure', message: error.message });
+      }
+    });
+
+    // Health check
+    this.app.get('/health', (req, res) => {
+      res.json({
+        status: 'healthy',
+        service: 'kinesis-firehose',
+        port: this.port,
+        stats: this.simulator.getStats()
+      });
+    });
+  }
+
+  async createDeliveryStream(req, res) {
+    const {
+      DeliveryStreamName,
+      DeliveryStreamType = 'DirectPut',
+      S3DestinationConfiguration,
+      HttpEndpointDestinationConfiguration,
+      RedshiftDestinationConfiguration
+    } = req.body;
+
+    if (!DeliveryStreamName) {
+      throw new Error('DeliveryStreamName is required');
+    }
+
+    const result = await this.simulator.createDeliveryStream(DeliveryStreamName, {
+      deliveryStreamType: DeliveryStreamType,
+      s3DestinationConfiguration: S3DestinationConfiguration,
+      httpEndpointDestinationConfiguration: HttpEndpointDestinationConfiguration,
+      redshiftDestinationConfiguration: RedshiftDestinationConfiguration
+    });
+
+    res.status(201).json(result);
+  }
+
+  async describeDeliveryStream(req, res) {
+    const { DeliveryStreamName } = req.body;
+
+    if (!DeliveryStreamName) {
+      throw new Error('DeliveryStreamName is required');
+    }
+
+    const result = this.simulator.describeDeliveryStream(DeliveryStreamName);
+    res.json(result);
+  }
+
+  async listDeliveryStreams(req, res) {
+    const { Limit, ExclusiveStartDeliveryStreamName } = req.body;
+
+    const result = this.simulator.listDeliveryStreams({
+      Limit,
+      ExclusiveStartDeliveryStreamName
+    });
+
+    res.json(result);
+  }
+
+  async deleteDeliveryStream(req, res) {
+    const { DeliveryStreamName } = req.body;
+
+    if (!DeliveryStreamName) {
+      throw new Error('DeliveryStreamName is required');
+    }
+
+    const result = await this.simulator.deleteDeliveryStream(DeliveryStreamName);
+    res.json(result);
+  }
+
+  async putRecord(req, res) {
+    const { DeliveryStreamName, Record } = req.body;
+
+    if (!DeliveryStreamName || !Record) {
+      throw new Error('DeliveryStreamName and Record are required');
+    }
+
+    const result = await this.simulator.putRecord(DeliveryStreamName, Record);
+    res.json(result);
+  }
+
+  async putRecordBatch(req, res) {
+    const { DeliveryStreamName, Records } = req.body;
+
+    if (!DeliveryStreamName || !Records || !Array.isArray(Records)) {
+      throw new Error('DeliveryStreamName and Records array are required');
+    }
+
+    const result = await this.simulator.putRecordBatch(DeliveryStreamName, Records);
+    res.json(result);
+  }
+
+  async updateDeliveryStream(req, res) {
+    const { DeliveryStreamName, ...config } = req.body;
+
+    if (!DeliveryStreamName) {
+      throw new Error('DeliveryStreamName is required');
+    }
+
+    const result = this.simulator.updateDeliveryStream(DeliveryStreamName, config);
+    res.json(result);
+  }
+
+  async describeDestination(req, res) {
+    const { DeliveryStreamName, DestinationId } = req.body;
+
+    if (!DeliveryStreamName || !DestinationId) {
+      throw new Error('DeliveryStreamName and DestinationId are required');
+    }
+
+    const result = this.simulator.describeDestination(DeliveryStreamName, DestinationId);
+    res.json(result);
+  }
+
+  async start() {
+    return new Promise((resolve, reject) => {
+      try {
+        this.server = this.app.listen(this.port, () => {
+          logger.info(`✅ Kinesis Firehose Server iniciado na porta ${this.port}`);
+          resolve();
+        });
+      } catch (error) {
+        logger.error(`❌ Erro ao iniciar Kinesis Firehose Server: ${error.message}`);
+        reject(error);
+      }
+    });
+  }
+
+  async stop() {
+    return new Promise((resolve, reject) => {
+      if (this.server) {
+        this.server.close((err) => {
+          if (err) {
+            logger.error(`Erro ao parar Kinesis Firehose Server: ${err.message}`);
+            reject(err);
+          } else {
+            logger.info('Kinesis Firehose Server parado');
+            resolve();
+          }
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+}
+
+module.exports = KinesisFirehoseServer;