@iota-big3/sdk-gateway
Version:
Universal API Gateway with protocol translation, intelligent routing, rate limiting, health checking, and caching
140 lines • 4.32 kB
JavaScript
;
/**
* @iota-big3/sdk-gateway
* Service Discovery Registry - Clean Implementation
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.ServiceDiscovery = void 0;
const events_1 = require("events");
class ServiceDiscovery extends events_1.EventEmitter {
constructor(config) {
super();
this.services = new Map();
this.provider = config.provider;
this.config = config.config;
}
/**
* Start service discovery
*/
async startAsync() {
// Service discovery started
this.emit('discovery:started');
// Initial discovery
await this.discoverServicesAsync();
// Set up periodic updates
if (this.config.updateInterval && typeof this.config.updateInterval === 'number') {
this.updateInterval = setInterval(() => this.discoverServicesAsync(), this.config.updateInterval);
}
}
/**
* Stop service discovery
*/
async stopAsync() {
if (this.updateInterval) {
clearInterval(this.updateInterval);
}
}
/**
* Discover services based on provider
*/
async discoverServicesAsync() {
try {
let services = [];
switch (this.provider) {
case 'static':
services = this.discoverStaticServices();
break;
case 'kubernetes':
services = await this.discoverKubernetesServicesAsync();
break;
case 'consul':
services = await this.discoverConsulServicesAsync();
break;
case 'etcd':
services = await this.discoverEtcdServicesAsync();
break;
}
services.forEach(service => this.registerService(service));
// Check for removed services
const currentIds = new Set(services.map(s => s.id));
for (const [id, service] of this.services) {
if (!currentIds.has(id)) {
this.services.delete(id);
this.emit('service:removed', service);
}
}
}
catch (error) {
this.emit('discovery:error', error);
}
}
/**
* Discover static services from config
*/
discoverStaticServices() {
const services = this.config.services || [];
return services.map((service) => ({
id: service.id,
name: service.name,
host: service.host,
port: service.port,
version: service.version,
endpoints: service.endpoints,
metadata: service.metadata,
healthCheck: service.healthCheck,
lastSeen: new Date()
}));
}
/**
* Placeholder for Kubernetes service discovery
*/
async discoverKubernetesServicesAsync() {
// Would implement actual Kubernetes API calls
return [];
}
/**
* Placeholder for Consul service discovery
*/
async discoverConsulServicesAsync() {
// Would implement actual Consul API calls
return [];
}
/**
* Placeholder for etcd service discovery
*/
async discoverEtcdServicesAsync() {
// Would implement actual etcd API calls
return [];
}
/**
* Register a service
*/
registerService(service) {
const existing = this.services.get(service.id);
if (!existing || this.hasChanged(existing, service)) {
this.services.set(service.id, service);
this.emit('service:updated', service);
}
}
/**
* Check if service has changed
*/
hasChanged(existing, updated) {
return JSON.stringify(existing.endpoints) !== JSON.stringify(updated.endpoints) ||
existing.version !== updated.version;
}
/**
* Get all discovered services
*/
getServices() {
return Array.from(this.services.values());
}
/**
* Get service by name
*/
getServiceByName(name) {
return Array.from(this.services.values()).find(s => s.name === name);
}
}
exports.ServiceDiscovery = ServiceDiscovery;
//# sourceMappingURL=service-registry.js.map