@gugananuvem/aws-local-simulator 1.0.34 → 1.0.39

package/src/services/kinesis-analytics/store.js

@@ -0,0 +1,176 @@
+/**
+ * Kinesis Data Analytics Store - Persistência de aplicações em JSON
+ */
+
+const path = require('path');
+const fs = require('fs');
+const logger = require('../../utils/logger');
+
+class KinesisAnalyticsStore {
+  constructor(dataDir) {
+    this.dataDir = dataDir;
+    this.applicationsDir = path.join(dataDir, 'kinesis-analytics');
+    this.metadataFile = path.join(this.applicationsDir, '__applications__.json');
+
+    if (!fs.existsSync(this.applicationsDir)) {
+      fs.mkdirSync(this.applicationsDir, { recursive: true });
+    }
+  }
+
+  /**
+   * Carrega metadados de todas as aplicações
+   */
+  loadMetadata() {
+    if (fs.existsSync(this.metadataFile)) {
+      try {
+        const data = fs.readFileSync(this.metadataFile, 'utf8');
+        return JSON.parse(data);
+      } catch (error) {
+        logger.warn(`Erro ao ler ${this.metadataFile}: ${error.message}`);
+        return {};
+      }
+    }
+    return {};
+  }
+
+  /**
+   * Salva metadados de todas as aplicações
+   */
+  saveMetadata(metadata) {
+    try {
+      fs.writeFileSync(this.metadataFile, JSON.stringify(metadata, null, 2), 'utf8');
+      logger.debug(`Metadados de aplicações salvos em ${this.metadataFile}`);
+    } catch (error) {
+      logger.error(`Erro ao salvar ${this.metadataFile}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Obtém caminho do arquivo de aplicação
+   */
+  getApplicationPath(applicationName) {
+    return path.join(this.applicationsDir, `${applicationName}.json`);
+  }
+
+  /**
+   * Carrega código SQL de uma aplicação
+   */
+  loadApplicationCode(applicationName) {
+    const appPath = this.getApplicationPath(applicationName);
+
+    if (!fs.existsSync(appPath)) {
+      return '';
+    }
+
+    try {
+      const data = fs.readFileSync(appPath, 'utf8');
+      const appData = JSON.parse(data);
+      return appData.sqlCode || '';
+    } catch (error) {
+      logger.warn(`Erro ao ler aplicação ${applicationName}: ${error.message}`);
+      return '';
+    }
+  }
+
+  /**
+   * Salva código SQL de uma aplicação
+   */
+  saveApplicationCode(applicationName, sqlCode) {
+    try {
+      const appPath = this.getApplicationPath(applicationName);
+      const appData = {
+        applicationName,
+        sqlCode,
+        lastModified: new Date().toISOString()
+      };
+      fs.writeFileSync(appPath, JSON.stringify(appData, null, 2), 'utf8');
+      logger.debug(`Código da aplicação ${applicationName} salvo`);
+    } catch (error) {
+      logger.error(`Erro ao salvar aplicação ${applicationName}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Carrega resultados de query
+   */
+  loadQueryResults(applicationName, queryId) {
+    const appPath = this.getApplicationPath(applicationName);
+
+    if (!fs.existsSync(appPath)) {
+      return [];
+    }
+
+    try {
+      const data = fs.readFileSync(appPath, 'utf8');
+      const appData = JSON.parse(data);
+      const queryResults = appData.queryResults || {};
+      return queryResults[queryId] || [];
+    } catch (error) {
+      logger.warn(`Erro ao ler resultados de query ${queryId}: ${error.message}`);
+      return [];
+    }
+  }
+
+  /**
+   * Salva resultados de query
+   */
+  saveQueryResults(applicationName, queryId, results) {
+    try {
+      const appPath = this.getApplicationPath(applicationName);
+      let appData = {};
+
+      if (fs.existsSync(appPath)) {
+        const data = fs.readFileSync(appPath, 'utf8');
+        appData = JSON.parse(data);
+      }
+
+      if (!appData.queryResults) {
+        appData.queryResults = {};
+      }
+
+      appData.queryResults[queryId] = results;
+      appData.lastModified = new Date().toISOString();
+
+      fs.writeFileSync(appPath, JSON.stringify(appData, null, 2), 'utf8');
+      logger.debug(`Resultados da query ${queryId} salvos para aplicação ${applicationName}`);
+    } catch (error) {
+      logger.error(`Erro ao salvar resultados de query ${queryId}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Deleta aplicação completamente
+   */
+  deleteApplication(applicationName) {
+    try {
+      const appPath = this.getApplicationPath(applicationName);
+      if (fs.existsSync(appPath)) {
+        fs.unlinkSync(appPath);
+        logger.debug(`Aplicação ${applicationName} deletada`);
+      }
+    } catch (error) {
+      logger.error(`Erro ao deletar aplicação ${applicationName}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Limpa todas as aplicações
+   */
+  clear() {
+    try {
+      if (fs.existsSync(this.applicationsDir)) {
+        const files = fs.readdirSync(this.applicationsDir);
+        files.forEach(file => {
+          if (file.endsWith('.json')) {
+            fs.unlinkSync(path.join(this.applicationsDir, file));
+          }
+        });
+        logger.debug('Todas as aplicações foram limpas');
+      }
+    } catch (error) {
+      logger.error(`Erro ao limpar aplicações: ${error.message}`);
+    }
+  }
+}
+
+module.exports = KinesisAnalyticsStore;

package/src/services/kinesis-data-streams/index.js

@@ -0,0 +1,106 @@
+/**
+ * Kinesis Data Streams Service - Ponto de entrada
+ */
+
+const KinesisDataStreamsServer = require('./server');
+const KinesisDataStreamsSimulator = require('./simulator');
+
+class KinesisDataStreamsService {
+  constructor(config) {
+    this.config = config;
+    this.name = 'kinesis-data-streams';
+    this.port = config.ports['kinesis-data-streams'] || 4568;
+    this.server = null;
+    this.simulator = null;
+    this.isRunning = false;
+  }
+
+  async initialize() {
+    const logger = require('../../utils/logger');
+    logger.debug(`Inicializando Kinesis Data Streams Service na porta ${this.port}...`);
+
+    this.simulator = new KinesisDataStreamsSimulator(this.config);
+    await this.simulator.initialize();
+
+    this.server = new KinesisDataStreamsServer(this.port, this.config);
+    this.server.simulator = this.simulator;
+
+    await this.server.initialize();
+
+    logger.debug('Kinesis Data Streams 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 Data Streams Service já está em execução');
+      return;
+    }
+
+    try {
+      await this.server.start();
+      this.isRunning = true;
+      logger.info('Kinesis Data Streams Service iniciado com sucesso');
+    } catch (error) {
+      logger.error(`Erro ao iniciar Kinesis Data Streams Service: ${error.message}`);
+      throw error;
+    }
+  }
+
+  async stop() {
+    const logger = require('../../utils/logger');
+
+    if (!this.isRunning) {
+      logger.warn('Kinesis Data Streams Service não está em execução');
+      return;
+    }
+
+    try {
+      await this.server.stop();
+      this.isRunning = false;
+      logger.info('Kinesis Data Streams Service parado com sucesso');
+    } catch (error) {
+      logger.error(`Erro ao parar Kinesis Data Streams Service: ${error.message}`);
+      throw error;
+    }
+  }
+
+  async reset() {
+    const logger = require('../../utils/logger');
+    try {
+      await this.simulator.reset();
+      logger.info('Kinesis Data Streams Service resetado');
+    } catch (error) {
+      logger.error(`Erro ao resetar Kinesis Data Streams Service: ${error.message}`);
+      throw error;
+    }
+  }
+
+  getSimulator() {
+    return this.simulator;
+  }
+
+  getStatus() {
+    const stats = this.simulator?.getStats() || { streamsCount: 0, consumersCount: 0, totalRecords: 0 };
+
+    return {
+      name: this.name,
+      running: this.isRunning,
+      port: this.port,
+      endpoint: `http://localhost:${this.port}`,
+      resources: {
+        streamsCount: stats.streamsCount,
+        consumersCount: stats.consumersCount,
+        totalRecords: stats.totalRecords,
+        totalShards: stats.totalShards
+      }
+    };
+  }
+}
+
+module.exports = KinesisDataStreamsService;

package/src/services/kinesis-data-streams/models/index.js

@@ -0,0 +1,12 @@
+/**
+ * Kinesis Data Streams Models
+ */
+
+const { Stream, Shard } = require('./stream');
+const Record = require('./record');
+
+module.exports = {
+  Stream,
+  Shard,
+  Record
+};

package/src/services/kinesis-data-streams/models/record.js

@@ -0,0 +1,70 @@
+/**
+ * Kinesis Data Streams - Record Model
+ * Representa um record (mensagem) dentro de um shard
+ */
+
+const { v4: uuidv4 } = require('uuid');
+
+class Record {
+  constructor(data, partitionKey, config = {}) {
+    this.recordId = uuidv4();
+    this.data = data; // Base64 encoded por padrão
+    this.partitionKey = partitionKey;
+    this.explicitHashKey = config.explicitHashKey || null;
+    this.sequenceNumber = null; // Será atribuído pelo shard
+    this.timestamp = new Date().toISOString();
+    this.approximateArrivalTimestamp = new Date();
+    
+    // Metadados
+    this.shardId = config.shardId || null;
+    this.encryptionType = config.encryptionType || 'NONE';
+    
+    // Dados do consumidor (quando acessado via consumer)
+    this.consumerSequenceNumber = null;
+    this.offsetInMilliseconds = null;
+  }
+
+  /**
+   * Retorna record em formato Kinesis (sem dados internos)
+   */
+  toJSON() {
+    return {
+      Data: this.data,
+      PartitionKey: this.partitionKey,
+      ExplicitHashKey: this.explicitHashKey,
+      SequenceNumber: this.sequenceNumber,
+      ApproximateArrivalTimestamp: this.approximateArrivalTimestamp.toISOString(),
+      EncryptionType: this.encryptionType
+    };
+  }
+
+  /**
+   * Retorna record em formato consumer
+   */
+  toConsumerJSON() {
+    return {
+      Data: this.data,
+      PartitionKey: this.partitionKey,
+      SequenceNumber: this.consumerSequenceNumber || this.sequenceNumber,
+      ApproximateArrivalTimestamp: this.approximateArrivalTimestamp.toISOString(),
+      EncryptionType: this.encryptionType
+    };
+  }
+
+  /**
+   * Obtém tamanho do record em bytes
+   */
+  getSize() {
+    return Buffer.byteLength(this.data) + Buffer.byteLength(this.partitionKey);
+  }
+
+  /**
+   * Marca record como consumido
+   */
+  markAsConsumed(consumerArn, sequenceNumber) {
+    this.consumerSequenceNumber = sequenceNumber;
+    this.offsetInMilliseconds = Date.now();
+  }
+}
+
+module.exports = Record;

package/src/services/kinesis-data-streams/models/stream.js

@@ -0,0 +1,280 @@
+/**
+ * Kinesis Data Streams - Stream Model
+ * Representa um stream Kinesis com seus shards, registros e metadados
+ */
+
+const { v4: uuidv4 } = require('uuid');
+
+class Stream {
+  constructor(streamName, config = {}) {
+    this.streamName = streamName;
+    this.streamArn = `arn:aws:kinesis:us-east-1:123456789012:stream/${streamName}`;
+    this.streamStatus = 'ACTIVE';
+    this.streamModeDetails = {
+      streamMode: config.streamMode || 'PROVISIONED'
+    };
+
+    // Configuração de shards (só para PROVISIONED)
+    this.shardCount = config.shardCount || 1;
+    this.shards = [];
+    this.initializeShards();
+
+    // Metadados
+    this.creationTimestamp = new Date().toISOString();
+    this.lastUpdateTimestamp = new Date().toISOString();
+    this.retentionPeriod = config.retentionPeriod || 24; // horas
+    this.enhancedMonitoring = config.enhancedMonitoring || ['ALL'];
+
+    // Consumidores
+    this.consumers = new Map();
+    this.consumerCount = 0;
+
+    // Estatísticas
+    this.recordCount = 0;
+    this.incomingRecords = 0;
+    this.incomingBytes = 0;
+
+    // Tags
+    this.tags = config.tags || {};
+  }
+
+  /**
+   * Inicializa shards
+   */
+  initializeShards() {
+    this.shards = [];
+    for (let i = 0; i < this.shardCount; i++) {
+      this.shards.push(new Shard(i, this.streamName));
+    }
+  }
+
+  /**
+   * Adiciona um shard
+   */
+  addShard() {
+    const newShard = new Shard(this.shards.length, this.streamName);
+    this.shards.push(newShard);
+    this.shardCount++;
+    this.lastUpdateTimestamp = new Date().toISOString();
+    return newShard;
+  }
+
+  /**
+   * Remove um shard (merge com outro)
+   */
+  removeShard(shardId) {
+    const index = this.shards.findIndex(s => s.shardId === shardId);
+    if (index !== -1) {
+      this.shards.splice(index, 1);
+      this.shardCount--;
+      this.lastUpdateTimestamp = new Date().toISOString();
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Obtém shard por ID
+   */
+  getShard(shardId) {
+    return this.shards.find(s => s.shardId === shardId);
+  }
+
+  /**
+   * Obtém todos os shards
+   */
+  getAllShards() {
+    return this.shards;
+  }
+
+  /**
+   * Seleciona shard baseado em partition key
+   */
+  selectShardByPartitionKey(partitionKey) {
+    if (this.shards.length === 0) return null;
+    
+    // Hash simples para distribuição uniforme
+    let hash = 0;
+    for (let i = 0; i < partitionKey.length; i++) {
+      const char = partitionKey.charCodeAt(i);
+      hash = ((hash << 5) - hash) + char;
+      hash = hash & hash; // Converte para 32-bit
+    }
+    
+    const shardIndex = Math.abs(hash) % this.shards.length;
+    return this.shards[shardIndex];
+  }
+
+  /**
+   * Registra um consumidor
+   */
+  registerConsumer(consumerArn, consumerName) {
+    if (!this.consumers.has(consumerArn)) {
+      this.consumers.set(consumerArn, {
+        consumerArn,
+        consumerName,
+        consumerStatus: 'ACTIVE',
+        consumerCreationTimestamp: new Date().toISOString(),
+        shardConsumers: new Map() // Map de shardId -> lastSequenceNumber
+      });
+      this.consumerCount++;
+    }
+    return this.consumers.get(consumerArn);
+  }
+
+  /**
+   * Remove consumidor
+   */
+  removeConsumer(consumerArn) {
+    if (this.consumers.has(consumerArn)) {
+      this.consumers.delete(consumerArn);
+      this.consumerCount--;
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Obtém consumidor
+   */
+  getConsumer(consumerArn) {
+    return this.consumers.get(consumerArn);
+  }
+
+  /**
+   * Atualiza estatísticas de incoming records
+   */
+  recordPutRecord(recordData) {
+    this.recordCount++;
+    this.incomingRecords++;
+    this.incomingBytes += Buffer.byteLength(JSON.stringify(recordData));
+    this.lastUpdateTimestamp = new Date().toISOString();
+  }
+
+  /**
+   * Retorna descrição do stream
+   */
+  describe() {
+    return {
+      StreamDescription: {
+        StreamName: this.streamName,
+        StreamArn: this.streamArn,
+        StreamStatus: this.streamStatus,
+        StreamModeDetails: this.streamModeDetails,
+        StreamCreationTimestamp: this.creationTimestamp,
+        Shards: this.shards.map(s => s.toJSON()),
+        HasMoreShards: false,
+        RetentionPeriod: this.retentionPeriod,
+        StreamLastUpdateTimestamp: this.lastUpdateTimestamp,
+        EnhancedMonitoring: this.enhancedMonitoring,
+        EncryptionType: 'NONE',
+        KeyId: null
+      }
+    };
+  }
+
+  toJSON() {
+    return {
+      streamName: this.streamName,
+      streamArn: this.streamArn,
+      streamStatus: this.streamStatus,
+      streamModeDetails: this.streamModeDetails,
+      creationTimestamp: this.creationTimestamp,
+      lastUpdateTimestamp: this.lastUpdateTimestamp,
+      shardCount: this.shardCount,
+      consumerCount: this.consumerCount,
+      retentionPeriod: this.retentionPeriod,
+      recordCount: this.recordCount,
+      incomingRecords: this.incomingRecords,
+      incomingBytes: this.incomingBytes
+    };
+  }
+}
+
+/**
+ * Shard Model - Partição dentro de um stream
+ */
+class Shard {
+  constructor(shardIndex, streamName) {
+    this.shardId = `shardId-${String(shardIndex).padStart(12, '0')}`;
+    this.shardName = `${streamName}-shard-${shardIndex}`;
+    this.shardStatus = 'ACTIVE';
+    this.parentShardId = null;
+    this.adjacentParentShardId = null;
+    
+    // Range de partition keys que este shard cobre
+    this.hashKeyRange = {
+      startingHashKey: '0',
+      endingHashKey: '18446744073709551615' // uint64 max
+    };
+
+    // Seqüência de números
+    this.sequenceNumberRange = {
+      startingSequenceNumber: '0',
+      endingSequenceNumber: null
+    };
+
+    this.creationTimestamp = new Date().toISOString();
+    
+    // Records armazenados neste shard
+    this.records = [];
+    this.recordCount = 0;
+    this.lastSequenceNumber = 0;
+  }
+
+  /**
+   * Adiciona um record ao shard
+   */
+  addRecord(record) {
+    record.sequenceNumber = (++this.lastSequenceNumber).toString();
+    this.records.push(record);
+    this.recordCount++;
+    return record;
+  }
+
+  /**
+   * Obtém records a partir de um sequence number
+   */
+  getRecords(startingSequenceNumber = null, limit = 100) {
+    let startIndex = 0;
+    
+    if (startingSequenceNumber) {
+      const seqNum = parseInt(startingSequenceNumber);
+      startIndex = this.records.findIndex(r => parseInt(r.sequenceNumber) > seqNum);
+      if (startIndex === -1) {
+        startIndex = this.records.length;
+      }
+    }
+
+    return this.records.slice(startIndex, startIndex + limit);
+  }
+
+  /**
+   * Obtém último record
+   */
+  getLastSequenceNumber() {
+    return this.lastSequenceNumber.toString();
+  }
+
+  /**
+   * Retorna todos os records
+   */
+  getAllRecords() {
+    return this.records;
+  }
+
+  toJSON() {
+    return {
+      ShardId: this.shardId,
+      ShardStatus: this.shardStatus,
+      HashKeyRange: this.hashKeyRange,
+      SequenceNumberRange: this.sequenceNumberRange,
+      CreationTimestamp: this.creationTimestamp
+    };
+  }
+}
+
+module.exports = {
+  Stream,
+  Shard
+};