git.zone/tspm
3
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

BREAKING CHANGE(daemon): Refactor daemon and service management: remove IPC auto-spawn, add TspmServiceManager, tighten IPC/client/CLI behavior and tests

Browse Source
This commit is contained in:
Jürgen Kunz
2025-08-28 15:52:29 +00:00
parent 8e3cfb624b
commit e73f4acd63
38 changed files with 810 additions and 580 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
test/test.daemon.ts
View File

@@ -13,18 +13,18 @@ tap.test('TspmDaemon creation', async () => {
tap.test('Daemon PID file management', async (tools) => {
const testDir = path.join(process.cwd(), '.nogit');
const testPidFile = path.join(testDir, 'test-daemon.pid');
// Create directory if it doesn't exist
await fs.mkdir(testDir, { recursive: true });
// Clean up any existing test file
await fs.unlink(testPidFile).catch(() => {});
// Test writing PID file
await fs.writeFile(testPidFile, process.pid.toString());
const pidContent = await fs.readFile(testPidFile, 'utf-8');
expect(parseInt(pidContent)).toEqual(process.pid);
// Clean up
await fs.unlink(testPidFile);
});
@@ -38,11 +38,11 @@ tap.test('Daemon socket path generation', async () => {
tap.test('Daemon shutdown handlers', async (tools) => {
const daemon = new TspmDaemon();
// Test that shutdown handlers are registered
const sigintListeners = process.listeners('SIGINT');
const sigtermListeners = process.listeners('SIGTERM');
// We expect at least one listener for each signal
// (Note: in actual test we won't start the daemon to avoid side effects)
expect(sigintListeners.length).toBeGreaterThanOrEqual(0);
@@ -52,7 +52,7 @@ tap.test('Daemon shutdown handlers', async (tools) => {
tap.test('Daemon process info tracking', async () => {
const daemon = new TspmDaemon();
const tspmInstance = (daemon as any).tspmInstance;
expect(tspmInstance).toBeDefined();
expect(tspmInstance.processes).toBeInstanceOf(Map);
expect(tspmInstance.processConfigs).toBeInstanceOf(Map);
@@ -61,7 +61,7 @@ tap.test('Daemon process info tracking', async () => {
tap.test('Daemon heartbeat monitoring setup', async (tools) => {
const daemon = new TspmDaemon();
// Test heartbeat interval property exists
const heartbeatInterval = (daemon as any).heartbeatInterval;
expect(heartbeatInterval).toEqual(null); // Should be null before start
@@ -70,13 +70,13 @@ tap.test('Daemon heartbeat monitoring setup', async (tools) => {
tap.test('Daemon shutdown state management', async () => {
const daemon = new TspmDaemon();
const isShuttingDown = (daemon as any).isShuttingDown;
expect(isShuttingDown).toEqual(false);
});
tap.test('Daemon memory usage reporting', async () => {
const memUsage = process.memoryUsage();
expect(memUsage.heapUsed).toBeGreaterThan(0);
expect(memUsage.heapTotal).toBeGreaterThan(0);
expect(memUsage.rss).toBeGreaterThan(0);
@@ -84,10 +84,10 @@ tap.test('Daemon memory usage reporting', async () => {
tap.test('Daemon CPU usage calculation', async () => {
const cpuUsage = process.cpuUsage();
expect(cpuUsage.user).toBeGreaterThanOrEqual(0);
expect(cpuUsage.system).toBeGreaterThanOrEqual(0);
// Test conversion to seconds
const cpuSeconds = cpuUsage.user / 1000000;
expect(cpuSeconds).toBeGreaterThanOrEqual(0);
@@ -95,13 +95,13 @@ tap.test('Daemon CPU usage calculation', async () => {
tap.test('Daemon uptime calculation', async () => {
const startTime = Date.now();
// Wait a bit
await new Promise(resolve => setTimeout(resolve, 100));
await new Promise((resolve) => setTimeout(resolve, 100));
const uptime = Date.now() - startTime;
expect(uptime).toBeGreaterThanOrEqual(100);
expect(uptime).toBeLessThan(200);
});
export default tap.start();
export default tap.start();

126
test/test.integration.ts
View File

@@ -10,7 +10,7 @@ import { tspmIpcClient } from '../ts/classes.ipcclient.js';
async function ensureDaemonStopped() {
try {
await tspmIpcClient.stopDaemon(false);
await new Promise(resolve => setTimeout(resolve, 1000));
await new Promise((resolve) => setTimeout(resolve, 1000));
} catch (error) {
// Ignore errors if daemon is not running
}
@@ -21,7 +21,7 @@ async function cleanupTestFiles() {
const tspmDir = path.join(os.homedir(), '.tspm');
const pidFile = path.join(tspmDir, 'daemon.pid');
const socketFile = path.join(tspmDir, 'tspm.sock');
await fs.unlink(pidFile).catch(() => {});
await fs.unlink(socketFile).catch(() => {});
}
@@ -29,55 +29,55 @@ async function cleanupTestFiles() {
// Integration tests for daemon-client communication
tap.test('Full daemon lifecycle test', async (tools) => {
const done = tools.defer();
// Ensure clean state
await ensureDaemonStopped();
await cleanupTestFiles();
// Test 1: Check daemon is not running
let status = await tspmIpcClient.getDaemonStatus();
expect(status).toEqual(null);
// Test 2: Start daemon
console.log('Starting daemon...');
await tspmIpcClient.connect();
// Give daemon time to fully initialize
await new Promise(resolve => setTimeout(resolve, 2000));
await new Promise((resolve) => setTimeout(resolve, 2000));
// Test 3: Check daemon is running
status = await tspmIpcClient.getDaemonStatus();
expect(status).toBeDefined();
expect(status?.status).toEqual('running');
expect(status?.pid).toBeGreaterThan(0);
expect(status?.processCount).toBeGreaterThanOrEqual(0);
// Test 4: Stop daemon
console.log('Stopping daemon...');
await tspmIpcClient.stopDaemon(true);
// Give daemon time to shutdown
await new Promise(resolve => setTimeout(resolve, 2000));
await new Promise((resolve) => setTimeout(resolve, 2000));
// Test 5: Check daemon is stopped
status = await tspmIpcClient.getDaemonStatus();
expect(status).toEqual(null);
done.resolve();
});
tap.test('Process management through daemon', async (tools) => {
const done = tools.defer();
// Ensure daemon is running
await tspmIpcClient.connect();
await new Promise(resolve => setTimeout(resolve, 1000));
await new Promise((resolve) => setTimeout(resolve, 1000));
// Test 1: List processes (should be empty initially)
let listResponse = await tspmIpcClient.request('list', {});
expect(listResponse.processes).toBeArray();
expect(listResponse.processes.length).toEqual(0);
// Test 2: Start a test process
const testConfig: tspm.IProcessConfig = {
id: 'test-echo',
@@ -87,52 +87,60 @@ tap.test('Process management through daemon', async (tools) => {
memoryLimitBytes: 50 * 1024 * 1024,
autorestart: false,
};
const startResponse = await tspmIpcClient.request('start', { config: testConfig });
const startResponse = await tspmIpcClient.request('start', {
config: testConfig,
});
expect(startResponse.processId).toEqual('test-echo');
expect(startResponse.status).toBeDefined();
// Test 3: List processes (should have one process)
listResponse = await tspmIpcClient.request('list', {});
expect(listResponse.processes.length).toBeGreaterThanOrEqual(1);
const process = listResponse.processes.find(p => p.id === 'test-echo');
const process = listResponse.processes.find((p) => p.id === 'test-echo');
expect(process).toBeDefined();
expect(process?.id).toEqual('test-echo');
// Test 4: Describe the process
const describeResponse = await tspmIpcClient.request('describe', { id: 'test-echo' });
const describeResponse = await tspmIpcClient.request('describe', {
id: 'test-echo',
});
expect(describeResponse.processInfo).toBeDefined();
expect(describeResponse.config).toBeDefined();
expect(describeResponse.config.id).toEqual('test-echo');
// Test 5: Stop the process
const stopResponse = await tspmIpcClient.request('stop', { id: 'test-echo' });
expect(stopResponse.success).toEqual(true);
expect(stopResponse.message).toInclude('stopped successfully');
// Test 6: Delete the process
const deleteResponse = await tspmIpcClient.request('delete', { id: 'test-echo' });
const deleteResponse = await tspmIpcClient.request('delete', {
id: 'test-echo',
});
expect(deleteResponse.success).toEqual(true);
// Test 7: Verify process is gone
listResponse = await tspmIpcClient.request('list', {});
const deletedProcess = listResponse.processes.find(p => p.id === 'test-echo');
const deletedProcess = listResponse.processes.find(
(p) => p.id === 'test-echo',
);
expect(deletedProcess).toBeUndefined();
// Cleanup: stop daemon
await tspmIpcClient.stopDaemon(true);
done.resolve();
});
tap.test('Batch operations through daemon', async (tools) => {
const done = tools.defer();
// Ensure daemon is running
await tspmIpcClient.connect();
await new Promise(resolve => setTimeout(resolve, 1000));
await new Promise((resolve) => setTimeout(resolve, 1000));
// Add multiple test processes
const testConfigs: tspm.IProcessConfig[] = [
{
@@ -152,43 +160,43 @@ tap.test('Batch operations through daemon', async (tools) => {
autorestart: false,
},
];
// Start processes
for (const config of testConfigs) {
await tspmIpcClient.request('start', { config });
}
// Test 1: Stop all processes
const stopAllResponse = await tspmIpcClient.request('stopAll', {});
expect(stopAllResponse.stopped).toBeArray();
expect(stopAllResponse.stopped.length).toBeGreaterThanOrEqual(2);
// Test 2: Start all processes
const startAllResponse = await tspmIpcClient.request('startAll', {});
expect(startAllResponse.started).toBeArray();
// Test 3: Restart all processes
const restartAllResponse = await tspmIpcClient.request('restartAll', {});
expect(restartAllResponse.restarted).toBeArray();
// Cleanup: delete all test processes
for (const config of testConfigs) {
await tspmIpcClient.request('delete', { id: config.id }).catch(() => {});
}
// Stop daemon
await tspmIpcClient.stopDaemon(true);
done.resolve();
});
tap.test('Daemon error handling', async (tools) => {
const done = tools.defer();
// Ensure daemon is running
await tspmIpcClient.connect();
await new Promise(resolve => setTimeout(resolve, 1000));
await new Promise((resolve) => setTimeout(resolve, 1000));
// Test 1: Try to stop non-existent process
try {
await tspmIpcClient.request('stop', { id: 'non-existent-process' });
@@ -196,7 +204,7 @@ tap.test('Daemon error handling', async (tools) => {
} catch (error) {
expect(error.message).toInclude('Failed to stop process');
}
// Test 2: Try to describe non-existent process
try {
await tspmIpcClient.request('describe', { id: 'non-existent-process' });
@@ -204,7 +212,7 @@ tap.test('Daemon error handling', async (tools) => {
} catch (error) {
expect(error.message).toInclude('not found');
}
// Test 3: Try to restart non-existent process
try {
await tspmIpcClient.request('restart', { id: 'non-existent-process' });
@@ -212,48 +220,48 @@ tap.test('Daemon error handling', async (tools) => {
} catch (error) {
expect(error.message).toInclude('Failed to restart process');
}
// Stop daemon
await tspmIpcClient.stopDaemon(true);
done.resolve();
});
tap.test('Daemon heartbeat functionality', async (tools) => {
const done = tools.defer();
// Ensure daemon is running
await tspmIpcClient.connect();
await new Promise(resolve => setTimeout(resolve, 1000));
await new Promise((resolve) => setTimeout(resolve, 1000));
// Test heartbeat
const heartbeatResponse = await tspmIpcClient.request('heartbeat', {});
expect(heartbeatResponse.timestamp).toBeGreaterThan(0);
expect(heartbeatResponse.status).toEqual('healthy');
// Stop daemon
await tspmIpcClient.stopDaemon(true);
done.resolve();
});
tap.test('Daemon memory and CPU reporting', async (tools) => {
const done = tools.defer();
// Ensure daemon is running
await tspmIpcClient.connect();
await new Promise(resolve => setTimeout(resolve, 1000));
await new Promise((resolve) => setTimeout(resolve, 1000));
// Get daemon status
const status = await tspmIpcClient.getDaemonStatus();
expect(status).toBeDefined();
expect(status?.memoryUsage).toBeGreaterThan(0);
expect(status?.cpuUsage).toBeGreaterThanOrEqual(0);
expect(status?.uptime).toBeGreaterThan(0);
// Stop daemon
await tspmIpcClient.stopDaemon(true);
done.resolve();
});
@@ -263,4 +271,4 @@ tap.test('Final cleanup', async () => {
await cleanupTestFiles();
});
export default tap.start();
export default tap.start();

56
test/test.ipcclient.ts
View File

@@ -14,7 +14,7 @@ tap.test('TspmIpcClient creation', async () => {
tap.test('IPC client socket path', async () => {
const client = new TspmIpcClient();
const socketPath = (client as any).socketPath;
expect(socketPath).toInclude('.tspm');
expect(socketPath).toInclude('tspm.sock');
});
@@ -22,7 +22,7 @@ tap.test('IPC client socket path', async () => {
tap.test('IPC client daemon PID file path', async () => {
const client = new TspmIpcClient();
const daemonPidFile = (client as any).daemonPidFile;
expect(daemonPidFile).toInclude('.tspm');
expect(daemonPidFile).toInclude('daemon.pid');
});
@@ -30,7 +30,7 @@ tap.test('IPC client daemon PID file path', async () => {
tap.test('IPC client connection state', async () => {
const client = new TspmIpcClient();
const isConnected = (client as any).isConnected;
expect(isConnected).toEqual(false); // Should be false initially
});
@@ -38,10 +38,10 @@ tap.test('IPC client daemon running check - no daemon', async () => {
const client = new TspmIpcClient();
const tspmDir = path.join(os.homedir(), '.tspm');
const pidFile = path.join(tspmDir, 'daemon.pid');
// Ensure no PID file exists for this test
await fs.unlink(pidFile).catch(() => {});
const isRunning = await (client as any).isDaemonRunning();
expect(isRunning).toEqual(false);
});
@@ -50,18 +50,21 @@ tap.test('IPC client daemon running check - stale PID', async () => {
const client = new TspmIpcClient();
const tspmDir = path.join(os.homedir(), '.tspm');
const pidFile = path.join(tspmDir, 'daemon.pid');
// Create directory if it doesn't exist
await fs.mkdir(tspmDir, { recursive: true });
// Write a fake PID that doesn't exist
await fs.writeFile(pidFile, '99999999');
const isRunning = await (client as any).isDaemonRunning();
expect(isRunning).toEqual(false);
// Clean up - the stale PID should be removed
const fileExists = await fs.access(pidFile).then(() => true).catch(() => false);
const fileExists = await fs
.access(pidFile)
.then(() => true)
.catch(() => false);
expect(fileExists).toEqual(false);
});
@@ -70,19 +73,19 @@ tap.test('IPC client daemon running check - current process', async () => {
const tspmDir = path.join(os.homedir(), '.tspm');
const pidFile = path.join(tspmDir, 'daemon.pid');
const socketFile = path.join(tspmDir, 'tspm.sock');
// Create directory if it doesn't exist
await fs.mkdir(tspmDir, { recursive: true });
// Write current process PID (simulating daemon is this process)
await fs.writeFile(pidFile, process.pid.toString());
// Create a fake socket file
await fs.writeFile(socketFile, '');
const isRunning = await (client as any).isDaemonRunning();
expect(isRunning).toEqual(true);
// Clean up
await fs.unlink(pidFile).catch(() => {});
await fs.unlink(socketFile).catch(() => {});
@@ -91,17 +94,19 @@ tap.test('IPC client daemon running check - current process', async () => {
tap.test('IPC client singleton instance', async () => {
// Import the singleton
const { tspmIpcClient } = await import('../ts/classes.ipcclient.js');
expect(tspmIpcClient).toBeInstanceOf(TspmIpcClient);
// Test that it's the same instance
const { tspmIpcClient: secondImport } = await import('../ts/classes.ipcclient.js');
const { tspmIpcClient: secondImport } = await import(
'../ts/classes.ipcclient.js'
);
expect(tspmIpcClient).toBe(secondImport);
});
tap.test('IPC client request method type safety', async () => {
const client = new TspmIpcClient();
// Test that request method exists
expect(client.request).toBeInstanceOf(Function);
expect(client.connect).toBeInstanceOf(Function);
@@ -111,17 +116,18 @@ tap.test('IPC client request method type safety', async () => {
});
tap.test('IPC client error message formatting', async () => {
const errorMessage = 'Could not connect to TSPM daemon. Please try running "tspm daemon start" manually.';
const errorMessage =
'Could not connect to TSPM daemon. Please try running "tspm daemon start" manually.';
expect(errorMessage).toInclude('tspm daemon start');
});
tap.test('IPC client reconnection logic', async () => {
const client = new TspmIpcClient();
// Test reconnection error conditions
const econnrefusedError = new Error('ECONNREFUSED');
expect(econnrefusedError.message).toInclude('ECONNREFUSED');
const enoentError = new Error('ENOENT');
expect(enoentError.message).toInclude('ENOENT');
});
@@ -129,7 +135,7 @@ tap.test('IPC client reconnection logic', async () => {
tap.test('IPC client daemon start timeout', async () => {
const maxWaitTime = 10000; // 10 seconds
const checkInterval = 500; // 500ms
const maxChecks = maxWaitTime / checkInterval;
expect(maxChecks).toEqual(20);
});
@@ -137,9 +143,9 @@ tap.test('IPC client daemon start timeout', async () => {
tap.test('IPC client daemon stop timeout', async () => {
const maxWaitTime = 15000; // 15 seconds
const checkInterval = 500; // 500ms
const maxChecks = maxWaitTime / checkInterval;
expect(maxChecks).toEqual(30);
});
export default tap.start();
export default tap.start();