sami7777/dashcaddy
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Sync DNS2 production changes - removed obsolete test suite and refactored structure

Browse Source
This commit is contained in:
Krystie
2026-03-23 10:47:15 +01:00
parent 1ac50918ab
commit d76644d948
288 changed files with 8965 additions and 15731 deletions
Download Patch File Download Diff File Expand all files Collapse all files

208
dashcaddy-api/routes/containers.js
View File

@@ -1,21 +1,14 @@
/**
* Container management routes
* Refactored to use explicit dependencies instead of ctx god object
*/
const express = require('express');
const { DOCKER } = require('../constants');
const { paginate, parsePaginationParams } = require('../pagination');
const { NotFoundError } = require('../errors');
const asyncHandler = require('../src/utils/async-handler');
const log = require('../src/utils/logger');
module.exports = function({ docker }) {
module.exports = function(ctx) {
const router = express.Router();
// Helper: verify container exists before operating on it
async function getVerifiedContainer(id) {
const container = docker.client.getContainer(id);
const container = ctx.docker.client.getContainer(id);
try {
await container.inspect();
} catch (err) {
@@ -28,143 +21,138 @@ module.exports = function({ docker }) {
}
// Start container
router.post('/:id/start', asyncHandler(async (req, res) => {
router.post('/:id/start', ctx.asyncHandler(async (req, res) => {
const container = await getVerifiedContainer(req.params.id);
await container.start();
res.json({ success: true, message: 'Container started' });
}, 'container-start'));
// Stop container
router.post('/:id/stop', asyncHandler(async (req, res) => {
router.post('/:id/stop', ctx.asyncHandler(async (req, res) => {
const container = await getVerifiedContainer(req.params.id);
await container.stop();
res.json({ success: true, message: 'Container stopped' });
}, 'container-stop'));
// Restart container
router.post('/:id/restart', asyncHandler(async (req, res) => {
router.post('/:id/restart', ctx.asyncHandler(async (req, res) => {
const container = await getVerifiedContainer(req.params.id);
await container.restart();
res.json({ success: true, message: 'Container restarted' });
}, 'container-restart'));
// Update container to latest image version
router.post('/:id/update', asyncHandler(async (req, res) => {
router.post('/:id/update', ctx.asyncHandler(async (req, res) => {
const containerId = req.params.id;
const container = await getVerifiedContainer(containerId);
// Get container info
const containerInfo = await container.inspect();
const imageName = containerInfo.Config.Image;
const containerName = containerInfo.Name.replace(/^\//, '');
// Get container info
const containerInfo = await container.inspect();
const imageName = containerInfo.Config.Image;
const containerName = containerInfo.Name.replace(/^\//, '');
log.info('docker', 'Updating container', { containerName, imageName });
ctx.log.info('docker', 'Updating container', { containerName, imageName });
// Pull the latest image
log.info('docker', `Pulling latest image: ${imageName}`);
await docker.pull(imageName);
// Pull the latest image
ctx.log.info('docker', `Pulling latest image: ${imageName}`);
await ctx.docker.pull(imageName);
// Get current container config for recreation
const hostConfig = containerInfo.HostConfig;
const config = {
Image: imageName,
name: containerName,
Env: containerInfo.Config.Env,
ExposedPorts: containerInfo.Config.ExposedPorts,
Labels: containerInfo.Config.Labels,
HostConfig: {
Binds: hostConfig.Binds,
PortBindings: hostConfig.PortBindings,
RestartPolicy: hostConfig.RestartPolicy,
NetworkMode: hostConfig.NetworkMode,
ExtraHosts: hostConfig.ExtraHosts,
Privileged: hostConfig.Privileged,
CapAdd: hostConfig.CapAdd,
CapDrop: hostConfig.CapDrop,
Devices: hostConfig.Devices,
LogConfig: DOCKER.LOG_CONFIG,
},
NetworkingConfig: {},
};
// Get network settings if using a custom network
if (hostConfig.NetworkMode && !['bridge', 'host', 'none'].includes(hostConfig.NetworkMode)) {
const networkName = hostConfig.NetworkMode;
config.NetworkingConfig.EndpointsConfig = {
[networkName]: containerInfo.NetworkSettings.Networks[networkName],
// Get current container config for recreation
const hostConfig = containerInfo.HostConfig;
const config = {
Image: imageName,
name: containerName,
Env: containerInfo.Config.Env,
ExposedPorts: containerInfo.Config.ExposedPorts,
Labels: containerInfo.Config.Labels,
HostConfig: {
Binds: hostConfig.Binds,
PortBindings: hostConfig.PortBindings,
RestartPolicy: hostConfig.RestartPolicy,
NetworkMode: hostConfig.NetworkMode,
ExtraHosts: hostConfig.ExtraHosts,
Privileged: hostConfig.Privileged,
CapAdd: hostConfig.CapAdd,
CapDrop: hostConfig.CapDrop,
Devices: hostConfig.Devices,
LogConfig: DOCKER.LOG_CONFIG // Ensure log rotation on updated containers
},
NetworkingConfig: {}
};
}
// Stop and remove old container
log.info('docker', 'Stopping container', { containerName });
await container.stop().catch(() => {}); // Ignore if already stopped
log.info('docker', 'Removing container', { containerName });
await container.remove();
// Get network settings if using a custom network
if (hostConfig.NetworkMode && !['bridge', 'host', 'none'].includes(hostConfig.NetworkMode)) {
const networkName = hostConfig.NetworkMode;
config.NetworkingConfig.EndpointsConfig = {
[networkName]: containerInfo.NetworkSettings.Networks[networkName]
};
}
// Wait for port release
await new Promise((r) => setTimeout(r, 3000));
// Stop and remove old container
ctx.log.info('docker', 'Stopping container', { containerName });
await container.stop().catch(() => {}); // Ignore if already stopped
ctx.log.info('docker', 'Removing container', { containerName });
await container.remove();
// Create and start new container
log.info('docker', 'Creating new container', { containerName });
let newContainer;
try {
newContainer = await docker.client.createContainer(config);
log.info('docker', 'Starting container', { containerName });
await newContainer.start();
} catch (startError) {
log.error('docker', 'Failed to start new container', { containerName, error: startError.message });
if (newContainer) {
try {
await newContainer.remove({ force: true });
} catch (e) {
/* already gone */
// Wait for port release (Windows/Docker Desktop can be slow to free ports)
await new Promise(r => setTimeout(r, 3000));
// Create and start new container
ctx.log.info('docker', 'Creating new container', { containerName });
let newContainer;
try {
newContainer = await ctx.docker.client.createContainer(config);
ctx.log.info('docker', 'Starting container', { containerName });
await newContainer.start();
} catch (startError) {
// Clean up the failed container so it doesn't block future attempts
ctx.log.error('docker', 'Failed to start new container', { containerName, error: startError.message });
if (newContainer) {
try { await newContainer.remove({ force: true }); } catch (e) { /* already gone */ }
}
throw startError;
}
throw startError;
}
const newContainerInfo = await newContainer.inspect();
const newContainerInfo = await newContainer.inspect();
// Prune dangling images
try {
const pruneResult = await docker.client.pruneImages({ filters: { dangling: { true: true } } });
if (pruneResult.SpaceReclaimed > 0) {
log.info('docker', 'Pruned dangling images after update', {
spaceReclaimed: `${Math.round(pruneResult.SpaceReclaimed / 1024 / 1024)}MB`,
});
// Prune dangling images after update
try {
const pruneResult = await ctx.docker.client.pruneImages({ filters: { dangling: { true: true } } });
if (pruneResult.SpaceReclaimed > 0) {
ctx.log.info('docker', 'Pruned dangling images after update', { spaceReclaimed: Math.round(pruneResult.SpaceReclaimed / 1024 / 1024) + 'MB' });
}
} catch (pruneErr) {
ctx.log.debug('docker', 'Image prune after update failed', { error: pruneErr.message });
}
} catch (pruneErr) {
log.debug('docker', 'Image prune after update failed', { error: pruneErr.message });
}
res.json({
success: true,
message: `Container ${containerName} updated successfully`,
newContainerId: newContainerInfo.Id,
});
res.json({
success: true,
message: `Container ${containerName} updated successfully`,
newContainerId: newContainerInfo.Id
});
}, 'container-update'));
// Check for available updates
router.get('/:id/check-update', asyncHandler(async (req, res) => {
// Check for available updates (compares local and remote image digests)
router.get('/:id/check-update', ctx.asyncHandler(async (req, res) => {
const containerId = req.params.id;
const container = await getVerifiedContainer(containerId);
const containerInfo = await container.inspect();
const imageName = containerInfo.Config.Image;
const localImage = docker.client.getImage(containerInfo.Image);
const localImage = ctx.docker.client.getImage(containerInfo.Image);
const localImageInfo = await localImage.inspect();
const localDigest = localImageInfo.RepoDigests?.[0] || null;
let updateAvailable = false;
try {
const pullStream = await docker.pull(imageName);
const pullStream = await ctx.docker.pull(imageName);
const downloadedLayers = pullStream.filter(
(e) => e.status === 'Downloading' || e.status === 'Download complete',
const downloadedLayers = pullStream.filter(e =>
e.status === 'Downloading' || e.status === 'Download complete'
);
updateAvailable = downloadedLayers.length > 0;
const newImage = docker.client.getImage(imageName);
const newImage = ctx.docker.client.getImage(imageName);
const newImageInfo = await newImage.inspect();
const newDigest = newImageInfo.RepoDigests?.[0] || null;
@@ -172,44 +160,44 @@ module.exports = function({ docker }) {
updateAvailable = true;
}
} catch (pullError) {
log.debug('docker', 'Could not check for updates', { error: pullError.message });
ctx.log.debug('docker', 'Could not check for updates', { error: pullError.message });
}
res.json({
success: true,
imageName,
updateAvailable,
currentDigest: localDigest,
currentDigest: localDigest
});
}, 'container-check-update'));
// Get container logs
router.get('/:id/logs', asyncHandler(async (req, res) => {
router.get('/:id/logs', ctx.asyncHandler(async (req, res) => {
const container = await getVerifiedContainer(req.params.id);
const logs = await container.logs({
stdout: true,
stderr: true,
tail: 100,
timestamps: true,
timestamps: true
});
res.json({ success: true, logs: logs.toString() });
}, 'container-logs'));
// Delete container
router.delete('/:id', asyncHandler(async (req, res) => {
router.delete('/:id', ctx.asyncHandler(async (req, res) => {
const container = await getVerifiedContainer(req.params.id);
await container.remove({ force: true });
res.json({ success: true, message: 'Container removed' });
}, 'container-delete'));
// Discover running containers
router.get('/discover', asyncHandler(async (req, res) => {
const containers = await docker.client.listContainers({ all: true });
const samiContainers = containers.filter(
(container) => container.Labels && container.Labels['sami.managed'] === 'true',
router.get('/discover', ctx.asyncHandler(async (req, res) => {
const containers = await ctx.docker.client.listContainers({ all: true });
const samiContainers = containers.filter(container =>
container.Labels && container.Labels['sami.managed'] === 'true'
);
const discoveredContainers = samiContainers.map((container) => ({
const discoveredContainers = samiContainers.map(container => ({
id: container.Id,
name: container.Names[0].replace('/', ''),
image: container.Image,
@@ -217,16 +205,12 @@ module.exports = function({ docker }) {
status: container.Status,
appTemplate: container.Labels['sami.app'],
subdomain: container.Labels['sami.subdomain'],
ports: container.Ports,
ports: container.Ports
}));
const paginationParams = parsePaginationParams(req.query);
const result = paginate(discoveredContainers, paginationParams);
res.json({
success: true,
containers: result.data,
...(result.pagination && { pagination: result.pagination }),
});
res.json({ success: true, containers: result.data, ...(result.pagination && { pagination: result.pagination }) });
}, 'containers-discover'));
return router;