Skip to content

ServerKit is a lightweight, modern server control panel for managing web applications, databases, and services on your VPS or dedicated server. Built with Python/Flask backend and React frontend.

16.4 KB
Raw Blame
import { useState, useEffect, useMemo, useCallback, useRef, useId } from 'react';
import api from '../../services/api';
import { useToast } from '../../contexts/useToast.js';
import { useConfirm } from '../../hooks/useConfirm';
import EmptyState from '../EmptyState';
import { ErrorState } from '../ErrorState';
import Modal from '@/components/Modal';
import { DataTable, DataTableFooter, Pill, SearchField, SegControl } from '@/components/ds';
import {
    useTableChrome, GridViewPicker, GridChips, GridFilterButton,
    GridToolsMenu, GridFilterDrawer,
} from '@/components/ds/grid';
import { useTableSort } from '@/hooks/useTableSort';
import { useColumnVisibility } from '@/hooks/useColumnVisibility';
import { Button } from '@/components/ui/button';
import { Input } from '@/components/ui/input';
import { Network as NetworkIcon, Trash2, Lock } from 'lucide-react';
import { useTranslation } from 'react-i18next';
import {
    useServer,
    normalizeListResponse,
    shortId,
} from './dockerHelpers';
import { toastError } from '@/utils/errorMessage';

export const CreateNetworkButton = () => {
    const { t } = useTranslation();
    const [showModal, setShowModal] = useState(false);
    const { isRemote } = useServer();
    return (
        <>
            <Button
                onClick={() => setShowModal(true)}
                disabled={isRemote}
                title={isRemote ? t('app.networksTab.creatingNetworksIsOnlyAvailableOn', 'Creating networks is only available on the panel server right now') : t('app.networksTab.createNetwork', 'Create network')}
            >
                <span>+</span> {t('app.networksTab.createNetwork2', 'Create network')}
            </Button>
            {showModal && <CreateNetworkModal onClose={() => setShowModal(false)} onCreated={() => window.location.reload()} />}
        </>
    );
};

const networkName = (network) => network.name || network.Name || '';
const networkId = (network) => network.id || network.ID || '';

// bridge/host/none ship with the daemon and cannot be removed. That was already
// encoded here as a hidden delete button; promoting it to a column is what
// turns "why can't I delete this one" into something the table says out loud —
// and gives the view below a rule to stand on.
const BUILTIN_NETWORKS = ['bridge', 'host', 'none'];
const networkKind = (network) => (
    BUILTIN_NETWORKS.includes(networkName(network)) ? 'Built-in' : 'User-defined'
);

const NO_RULES = { match: 'all', rules: [] };
const PAGE_CLEAR = { search: '' };

const NETWORK_VIEWS = [
    {
        // Everything someone on this host created — the only rows with an
        // action, and the ones a stale compose project leaves behind.
        name: 'User-defined',
        state: {
            sorts: [{ key: 'name', direction: 'asc' }],
            hiddenKeys: [],
            groupBy: null,
            columnFilters: {
                match: 'all',
                rules: [{ id: 'dn1', field: 'kind', op: 'any', value: ['User-defined'] }],
            },
            page: PAGE_CLEAR,
        },
    },
    {
        // No rules, bucketed by driver: bridge networks are per-host, overlay
        // ones span the swarm, and mixing them in one list hides that.
        name: 'By driver',
        state: {
            sorts: [{ key: 'name', direction: 'asc' }],
            hiddenKeys: [],
            groupBy: 'driver',
            columnFilters: NO_RULES,
            page: PAGE_CLEAR,
        },
    },
    {
        // The way back out of either of the above.
        name: 'All networks',
        state: {
            sorts: [{ key: 'name', direction: 'asc' }],
            hiddenKeys: [],
            groupBy: null,
            columnFilters: NO_RULES,
            page: PAGE_CLEAR,
        },
    },
];

// Networks Tab
const NetworksTab = ({ onStatsChange }) => {
    const { t } = useTranslation();
    const toast = useToast();
    const { serverId, isRemote } = useServer();
    const { confirm: confirmNetwork } = useConfirm();
    const [networks, setNetworks] = useState([]);
    const [loading, setLoading] = useState(true);
    const [searchTerm, setSearchTerm] = useState('');
    const { sorts, setSorts } = useTableSort({
        defaultSorts: [{ key: 'name', direction: 'asc' }],
        storageKey: 'serverkit-table-docker-networks-sort',
    });
    const { hiddenKeys, setHiddenKeys } = useColumnVisibility({
        storageKey: 'serverkit-table-docker-networks-cols',
    });
    const [groupBy, setGroupBy] = useState(null);

    // Only the newest load may write: see ContainersTab.
    const loadSeq = useRef(0);
    const [loadError, setLoadError] = useState(null);

    useEffect(() => {
        loadNetworks();
    }, [serverId]); // eslint-disable-line react-hooks/exhaustive-deps

    async function loadNetworks() {
        const seq = ++loadSeq.current;
        setLoading(true);
        setLoadError(null);
        try {
            let data;
            if (isRemote) {
                const result = await api.getRemoteNetworks(serverId);
                data = { networks: normalizeListResponse(result, 'networks') };
            } else {
                data = await api.getNetworks();
            }
            if (seq !== loadSeq.current) return;
            setNetworks(data.networks || []);
            setLoading(false);
        } catch (err) {
            if (seq !== loadSeq.current) return;
            setNetworks([]);
            setLoadError(err);
            setLoading(false);
        }
    }

    async function handleRemove(network) {
        const confirmed = await confirmNetwork({ titleKey: 'app.networksTab.removeNetwork', title: 'Delete network', messageKey: 'app.networksTab.removeThisNetwork', message: 'Delete this network?', confirmText: t('common.actions.delete', 'Delete') });
        if (!confirmed) return;

        try {
            if (isRemote) {
                await api.removeRemoteNetwork(serverId, networkId(network));
            } else {
                await api.removeNetwork(networkId(network));
            }
            toast.success(t('app.networksTab.networkRemovedSuccessfully', 'Network deleted'));
            loadNetworks();
            onStatsChange?.();
        } catch (err) {
            console.error('Failed to remove network:', err);
            toastError(toast, t('app.networksTab.failedToRemoveNetworkItMay', "Couldn't delete the network. A container may still use it."), err);
        }
    }

    const filteredNetworks = useMemo(() => {
        const search = searchTerm.toLowerCase();
        if (!search) return networks;
        return networks.filter((network) => (
            networkName(network).toLowerCase().includes(search) ||
            networkId(network).toLowerCase().includes(search)
        ));
    }, [networks, searchTerm]);

    // Every derived column carries BOTH `value` (rules, grouping, export) and
    // `render` (the cell). One without the other renders blank.
    const columns = [
        {
            key: 'name',
            headerKey: 'common.labels.name', header: 'Name',
            sortable: true,
            hideable: false,
            type: 'text',
            value: networkName,
            sortValue: networkName,
            render: (network) => (
                <div className="dx-name-stack">
                    <span className="dx-name-line">
                        <span title={networkName(network)}>{networkName(network)}</span>
                    </span>
                    <span className="dx-muted-line mono">{shortId(networkId(network))}</span>
                </div>
            ),
        },
        {
            key: 'kind',
            headerKey: 'common.labels.kind', header: 'Kind',
            sortable: true,
            // Declared: three built-ins plus one custom network is a two-value
            // column that infers as text, which would turn the view above into a
            // typed fragment rather than a pick-list.
            type: 'enum',
            enumOrder: ['User-defined', 'Built-in'],
            width: 130,
            value: networkKind,
            sortValue: networkKind,
            render: (network) => (
                <Pill kind={networkKind(network) === 'Built-in' ? 'gray' : 'cyan'} dot={false}>
                    {networkKind(network)}
                </Pill>
            ),
        },
        {
            key: 'driver',
            headerKey: 'app.networksTab.driver', header: 'Driver',
            sortable: true,
            type: 'enum',
            groupable: true,
            width: 130,
            value: (network) => network.driver || network.Driver || '-',
            groupValue: (network) => network.driver || network.Driver || '-',
            sortValue: (network) => network.driver || network.Driver || '-',
            render: (network) => (
                <span className="dx-code-pill">{network.driver || network.Driver || '-'}</span>
            ),
        },
        {
            key: 'scope',
            headerKey: 'app.networksTab.scope', header: 'Scope',
            sortable: true,
            type: 'enum',
            width: 110,
            value: (network) => network.scope || network.Scope || '-',
            sortValue: (network) => network.scope || network.Scope || '-',
            render: (network) => (
                <span className="dx-muted-line">{network.scope || network.Scope || '-'}</span>
            ),
        },
        {
            key: '__actions',
            header: '',
            sortable: false,
            hideable: false,
            width: 110,
            className: 'text-right',
            render: (network) => (
                <div className="dx-row-actions">
                    {networkKind(network) === 'Built-in' ? (
                        <span className="dx-row-protected" title={t('app.networksTab.shipsWithTheDockerDaemonIt', 'Ships with the Docker daemon, so it cannot be deleted')}>
                            <Lock size={11} /> {t('common.labels.system', 'System')}
                        </span>
                    ) : (
                        <Button variant="unstyled"
                            type="button"
                            className="dx-row-action is-danger"
                            onClick={() => handleRemove(network)}
                            title={t('app.networksTab.removeNetwork2', 'Delete network')}
                        >
                            <Trash2 size={13} />
                        </Button>
                    )}
                </div>
            ),
        },
    ];

    const viewPageState = useMemo(() => ({ search: searchTerm }), [searchTerm]);
    const applyViewPageState = useCallback((saved) => {
        if (saved.search !== undefined) setSearchTerm(saved.search);
    }, []);

    // Chrome INLINE in the picker's `actions` — the Docker page owns the top bar
    // above this panel. `urlScope` because that one route renders five of these
    // tables, and the link params (`view`, `sort`, `hide`, `f`…) are global
    // names: unscoped, the networks view would arrive as the images view.
    const chrome = useTableChrome({
        columns,
        rows: filteredNetworks,
        viewPageKey: 'docker-networks',
        urlScope: 'networks',
        builtinViews: NETWORK_VIEWS,
        noun: 'networks',
        sorts,
        setSorts,
        hiddenKeys,
        setHiddenKeys,
        groupBy,
        setGroupBy,
        pageState: viewPageState,
        applyPage: applyViewPageState,
    });

    if (loading) {
        return (
            <div className="dx-tab-pane">
                <div className="docker-loading">{t('app.networksTab.loadingNetworks', 'Loading networks…')}</div>
            </div>
        );
    }

    return (
        <div className="dx-tab-pane dx-list-pane">
            <GridViewPicker
                views={chrome.views}
                label="networks"
                onCreate={chrome.createView}
                actions={(
                    <>
                        <SearchField
                            value={searchTerm}
                            onSearch={setSearchTerm}
                            placeholder={t('app.networksTab.filterNameOrId', 'Filter name or ID…')}
                        />
                        <GridFilterButton
                            count={chrome.filterCount}
                            onClick={() => chrome.setDrawerOpen(true)}
                        />
                        <GridToolsMenu {...chrome.toolsProps} onRefresh={loadNetworks} />
                    </>
                )}
            />

            <GridChips {...chrome.chipProps} />

            {loadError ? (
                <ErrorState error={loadError} onRetry={loadNetworks} />
            ) : filteredNetworks.length === 0 ? (
                <EmptyState
                    icon={NetworkIcon}
                    title={networks.length === 0 ? t('app.networksTab.noNetworks', 'No networks') : t('app.networksTab.noMatchingNetworks', 'No matching networks')}
                    description={networks.length === 0
                        ? t('app.networksTab.createANetworkToConnectContainers', 'Create a network to connect containers.')
                        : t('app.networksTab.noNetworksMatchTheCurrentSearch', 'No networks match the current search.')}
                />
            ) : (
                <section className="dx-resource-list">
                    <DataTable
                        {...chrome.tableProps}
                        columns={chrome.columns}
                        data={filteredNetworks}
                        keyField={(network) => networkId(network) || networkName(network)}
                        sorts={sorts}
                        onSortsChange={setSorts}
                        groupBy={groupBy}
                        onGroupByChange={setGroupBy}
                        className="dx-table-wrap sk-dtable-wrap--sticky"
                        footer={(
                            <DataTableFooter
                                shown={chrome.shownCount}
                                total={networks.length}
                                noun="network"
                            />
                        )}
                    />
                </section>
            )}

            <GridFilterDrawer {...chrome.drawerProps} />
        </div>
    );
};

const CreateNetworkModal = ({ onClose, onCreated }) => {
    const fieldId = useId();
    const { t } = useTranslation();
    const [name, setName] = useState('');
    const [driver, setDriver] = useState('bridge');
    const [loading, setLoading] = useState(false);
    const [error, setError] = useState('');

    async function handleSubmit(e) {
        e.preventDefault();
        setError('');
        setLoading(true);

        try {
            await api.createNetwork(name, driver);
            onCreated();
            onClose();
        } catch (err) {
            setError(err.message || 'Failed to create network');
        } finally {
            setLoading(false);
        }
    }

    return (
        <Modal open onClose={onClose} title={t('app.networksTab.createNetwork2', 'Create network')} size="md">
            {error && <div className="error-message">{error}</div>}

            <form onSubmit={handleSubmit}>
                <div className="form-group">
                    <label htmlFor={`${fieldId}-name`}>{t('app.networksTab.networkName', 'Network name *')}</label>
                    <Input
                        id={`${fieldId}-name`}
                        type="text"
                        value={name}
                        onChange={(e) => setName(e.target.value)}
                        placeholder="my-network"
                        required
                    />
                </div>

                <div className="form-group">
                    <label>{t('app.networksTab.driver', 'Driver')}</label>
                    <SegControl
                        aria-label={t('app.networksTab.driver', 'Driver')}
                        value={driver}
                        onChange={setDriver}
                        options={['bridge', 'overlay', 'macvlan']}
                    />
                </div>

                <div className="modal-actions">
                    <Button type="button" variant="outline" onClick={onClose}>
                        {t('common.actions.cancel', 'Cancel')}
                    </Button>
                    <Button type="submit" disabled={loading}>
                        {loading ? t('app.networksTab.creating', 'Creating…') : t('app.networksTab.createNetwork', 'Create network')}
                    </Button>
                </div>
            </form>
        </Modal>
    );
};

export default NetworksTab;