kova-node-cli 0.1.0

package/dist/services/heartbeat.js

@@ -0,0 +1,110 @@
+import { EventEmitter } from 'events';
+import { logger } from '../lib/logger.js';
+export class HeartbeatService extends EventEmitter {
+    nodeId;
+    orchestratorUrl;
+    monitor;
+    limitManager;
+    interval = null;
+    heartbeatIntervalMs;
+    isRunning = false;
+    apiPort;
+    accessToken;
+    constructor(nodeId, orchestratorUrl, monitor, limitManager, intervalSeconds = 60, apiPort = 4002, accessToken = '') {
+        super();
+        this.nodeId = nodeId;
+        this.orchestratorUrl = orchestratorUrl;
+        this.monitor = monitor;
+        this.limitManager = limitManager;
+        this.heartbeatIntervalMs = intervalSeconds * 1000;
+        this.apiPort = apiPort;
+        this.accessToken = accessToken;
+    }
+    async start() {
+        if (this.isRunning) {
+            logger.warn('heartbeat service already running');
+            return;
+        }
+        this.isRunning = true;
+        // send initial heartbeat immediately
+        await this.sendHeartbeat();
+        // then send periodic heartbeats
+        this.interval = setInterval(async () => {
+            await this.sendHeartbeat();
+        }, this.heartbeatIntervalMs);
+        logger.info({ intervalSeconds: this.heartbeatIntervalMs / 1000 }, 'heartbeat service started');
+    }
+    async stop() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+        this.isRunning = false;
+        logger.info('heartbeat service stopped');
+    }
+    async sendHeartbeat() {
+        if (!this.isRunning)
+            return;
+        try {
+            // get system resources
+            const systemResources = await this.monitor.getAvailableResources();
+            const availableLimits = this.limitManager.getAvailableResources();
+            // send provider limits, not system resources
+            const resources = {
+                cpu: {
+                    cores: this.limitManager.getLimits().cpu,
+                    available: availableLimits.cpu
+                },
+                memory: {
+                    total: this.limitManager.getLimits().memory,
+                    available: availableLimits.memory
+                },
+                disk: systemResources.disk,
+                network: systemResources.network,
+                gpu: systemResources.gpu || []
+            };
+            // send heartbeat to orchestrator
+            const response = await fetch(`${this.orchestratorUrl}/api/v1/nodes/${this.nodeId}/heartbeat`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    resources,
+                    apiPort: this.apiPort,
+                    accessToken: this.accessToken,
+                }),
+            });
+            if (response.ok) {
+                const data = await response.json();
+                logger.debug({
+                    nodeId: this.nodeId,
+                    cpu: resources.cpu.available,
+                    memory: resources.memory.available,
+                }, 'heartbeat sent successfully');
+                this.emit('heartbeat-success', { resources, timestamp: data.timestamp || Date.now() });
+                // check if orchestrator sent pending jobs
+                if (data.pendingJobs && data.pendingJobs.length > 0) {
+                    logger.info({ count: data.pendingJobs.length }, 'received pending jobs from heartbeat');
+                    this.emit('pending-jobs', data.pendingJobs);
+                }
+            }
+            else {
+                const error = await response.text();
+                logger.warn({ status: response.status, error }, 'heartbeat request failed');
+                this.emit('heartbeat-error', { status: response.status, error });
+            }
+        }
+        catch (err) {
+            logger.error({ err }, 'failed to send heartbeat');
+            this.emit('heartbeat-error', { error: err });
+        }
+    }
+    // manually trigger a heartbeat
+    async triggerHeartbeat() {
+        await this.sendHeartbeat();
+    }
+    isActive() {
+        return this.isRunning;
+    }
+}

package/dist/services/job-handler.js

@@ -0,0 +1,241 @@
+import { EventEmitter } from 'events';
+import { logger } from '../lib/logger.js';
+import { UsageMeter } from '../lib/usage-meter.js';
+export class JobHandler extends EventEmitter {
+    containerManager;
+    p2pNode;
+    activeJobs = new Map();
+    maxConcurrentJobs = 3;
+    usageMeter;
+    limitManager;
+    orchestratorUrl;
+    constructor(p2pNode, containerManager, limitManager, orchestratorUrl) {
+        super();
+        this.p2pNode = p2pNode;
+        this.containerManager = containerManager;
+        this.limitManager = limitManager;
+        this.orchestratorUrl = orchestratorUrl;
+        this.usageMeter = new UsageMeter();
+        this.setupContainerListeners();
+        this.setupP2PListeners();
+    }
+    setupP2PListeners() {
+        this.p2pNode.on('job-cancel', ({ jobId }) => {
+            logger.info({ jobId }, 'received cancellation request');
+            this.cancelJob(jobId);
+        });
+    }
+    setupContainerListeners() {
+        this.containerManager.on('container-started', ({ jobId, containerId }) => {
+            const job = this.activeJobs.get(jobId);
+            if (job) {
+                job.status = 'running';
+                job.containerId = containerId;
+                // start tracking usage
+                this.usageMeter.startMeter(jobId, this.p2pNode.getPeerId(), job.spec.userId);
+                this.emit('job-started', { jobId });
+            }
+        });
+        // track resource usage as container runs
+        this.containerManager.on('container-stats', ({ jobId, stats }) => {
+            this.usageMeter.updateUsage(jobId, {
+                cpu: stats.cpu / 100, // percentage to cores
+                memory: stats.memory / 1024, // mb to gb
+                network: stats.network
+            });
+        });
+        this.containerManager.on('container-finished', ({ jobId, exitCode, logs }) => {
+            const job = this.activeJobs.get(jobId);
+            if (job) {
+                job.status = exitCode === 0 ? 'completed' : 'failed';
+                job.endTime = Date.now();
+                job.result = { exitCode, logs };
+                // release allocated resources
+                this.limitManager.releaseResources(jobId, job.spec.resources);
+                // finalize usage tracking and calculate actual cost
+                const pricing = {
+                    cpuPerHour: 0.05,
+                    memoryPerGBHour: 0.02,
+                    storagePerGBHour: 0.001,
+                    networkPerGB: 0.01
+                };
+                const usageRecord = this.usageMeter.finalizeMeter(jobId, pricing);
+                if (usageRecord) {
+                    job.earnings = usageRecord.cost.toNumber();
+                    logger.info({ jobId, usage: usageRecord.usage, cost: job.earnings }, 'usage calculated');
+                }
+                else {
+                    // fallback to simple time-based calc
+                    const runtime = (job.endTime - job.startTime) / 1000 / 60 / 60;
+                    const hourlyRate = job.spec.price || this.calculatePrice(job.spec);
+                    job.earnings = runtime * hourlyRate;
+                }
+                this.emit('job-completed', { jobId, earnings: job.earnings });
+                // report back to orchestrator
+                this.reportJobCompletion(jobId, job);
+            }
+        });
+        this.containerManager.on('container-failed', ({ jobId, error }) => {
+            const job = this.activeJobs.get(jobId);
+            if (job) {
+                job.status = 'failed';
+                job.endTime = Date.now();
+                job.error = error;
+                // release resources
+                this.limitManager.releaseResources(jobId, job.spec.resources);
+                this.emit('job-failed', { jobId, error });
+                this.reportJobCompletion(jobId, job);
+            }
+        });
+    }
+    async handleJob(jobSpec) {
+        const runningJobs = Array.from(this.activeJobs.values())
+            .filter(j => j.status === 'running').length;
+        if (runningJobs >= this.maxConcurrentJobs) {
+            logger.warn({ jobId: jobSpec.id }, 'at max capacity');
+            return false;
+        }
+        // check against provider-configured limits
+        if (!this.limitManager.canAcceptJob(jobSpec.resources)) {
+            logger.warn({ jobId: jobSpec.id, required: jobSpec.resources }, 'exceeds provider limits');
+            return false;
+        }
+        // allocate the resources
+        if (!this.limitManager.allocateResources(jobSpec.id, jobSpec.resources)) {
+            logger.warn({ jobId: jobSpec.id }, 'failed to allocate resources');
+            return false;
+        }
+        const job = {
+            jobId: jobSpec.id,
+            spec: jobSpec,
+            status: 'received',
+            startTime: Date.now()
+        };
+        this.activeJobs.set(jobSpec.id, job);
+        logger.info({ jobId: jobSpec.id }, 'accepted job');
+        try {
+            job.status = 'starting';
+            await this.containerManager.runJob(jobSpec);
+            return true;
+        }
+        catch (err) {
+            logger.error({ err, jobId: jobSpec.id }, 'failed to start job');
+            job.status = 'failed';
+            job.error = err;
+            job.endTime = Date.now();
+            // release resources on failure
+            this.limitManager.releaseResources(jobSpec.id, jobSpec.resources);
+            return false;
+        }
+    }
+    calculatePrice(spec) {
+        // basic pricing if not specified
+        return spec.resources.cpu * 0.05 + spec.resources.memory * 0.02;
+    }
+    async reportJobCompletion(jobId, job) {
+        const nodeId = this.p2pNode.getPeerId();
+        // try http callback first (more reliable than p2p)
+        if (this.orchestratorUrl) {
+            try {
+                await fetch(`${this.orchestratorUrl}/api/v1/nodes/${nodeId}/jobs/${jobId}/complete`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        success: job.status === 'completed',
+                        result: job.result,
+                        usage: {
+                            runtime: job.endTime ? (job.endTime - job.startTime) / 1000 : 0,
+                            cost: job.earnings || 0
+                        }
+                    })
+                });
+                logger.info({
+                    jobId,
+                    status: job.status,
+                    runtime: job.endTime ? (job.endTime - job.startTime) / 1000 : 0,
+                    earnings: job.earnings
+                }, 'reported job completion via http');
+            }
+            catch (err) {
+                logger.warn({ err, jobId }, 'failed to report via http, trying p2p');
+                // fallback to p2p
+                const completionMessage = {
+                    type: 'job-completed',
+                    data: {
+                        jobId,
+                        success: job.status === 'completed',
+                        result: job.result,
+                        usage: {
+                            runtime: job.endTime ? (job.endTime - job.startTime) / 1000 : 0,
+                            cost: job.earnings || 0
+                        },
+                        nodeId
+                    }
+                };
+                await this.p2pNode.sendToOrchestrator(completionMessage);
+                logger.info({ jobId }, 'reported job completion via p2p');
+            }
+        }
+        else {
+            // no http url, use p2p only
+            const completionMessage = {
+                type: 'job-completed',
+                data: {
+                    jobId,
+                    success: job.status === 'completed',
+                    result: job.result,
+                    usage: {
+                        runtime: job.endTime ? (job.endTime - job.startTime) / 1000 : 0,
+                        cost: job.earnings || 0
+                    },
+                    nodeId
+                }
+            };
+            await this.p2pNode.sendToOrchestrator(completionMessage);
+            logger.info({ jobId }, 'reported job completion via p2p');
+        }
+        setTimeout(() => {
+            this.activeJobs.delete(jobId);
+        }, 60000);
+    }
+    getActiveJobs() {
+        return Array.from(this.activeJobs.values());
+    }
+    getTotalEarnings() {
+        let total = 0;
+        for (const job of this.activeJobs.values()) {
+            if (job.earnings) {
+                total += job.earnings;
+            }
+        }
+        return total;
+    }
+    async cancelJob(jobId) {
+        const job = this.activeJobs.get(jobId);
+        if (!job) {
+            logger.warn({ jobId }, 'job not found for cancellation');
+            return false;
+        }
+        if (job.status === 'completed' || job.status === 'failed') {
+            logger.warn({ jobId }, 'job already finished, cannot cancel');
+            return false;
+        }
+        try {
+            // stop the container if running
+            if (job.containerId) {
+                await this.containerManager.stopContainer(job.containerId);
+            }
+            job.status = 'failed';
+            job.endTime = Date.now();
+            job.error = { message: 'cancelled by orchestrator' };
+            logger.info({ jobId }, 'job cancelled successfully');
+            // report cancellation
+            await this.reportJobCompletion(jobId, job);
+            return true;
+        }
+        catch (err) {
+            logger.error({ err, jobId }, 'failed to cancel job');
+            return false;
+        }
+    }
+}