/* * Copyright (C) 2023 Red Hat, Inc. * SPDX-License-Identifier: LGPL-2.1-or-later */ import cockpit from "cockpit"; import React from "react"; import client from "../client"; import { Alert } from "@patternfly/react-core/dist/esm/components/Alert/index.js"; import { Card, CardBody } from '@patternfly/react-core/dist/esm/components/Card/index.js'; import { DescriptionList, DescriptionListDescription, DescriptionListGroup, DescriptionListTerm } from "@patternfly/react-core/dist/esm/components/DescriptionList/index.js"; import { block_short_name, get_active_usage, teardown_active_usage, fmt_size, decode_filename, reload_systemd } from "../utils.js"; import { dialog_open, SizeSlider, BlockingMessage, TeardownMessage, init_teardown_usage } from "../dialog.jsx"; import { StorageButton, StorageOnOff } from "../storage-controls.jsx"; import { StorageCard, new_page, new_card } from "../pages.jsx"; import { make_block_page } from "../block/create-pages.jsx"; import inotify_py from "inotify.py"; import vdo_monitor_py from "./vdo-monitor.py"; const _ = cockpit.gettext; export function make_legacy_vdo_page(parent, vdo, backing_block, next_card) { const block = client.slashdevs_block[vdo.dev]; function stop() { const usage = get_active_usage(client, block ? block.path : "/", _("stop")); if (usage.Blocking) { dialog_open({ Title: cockpit.format(_("$0 is in use"), vdo.name), Body: BlockingMessage(usage), }); return; } if (usage.Teardown) { dialog_open({ Title: cockpit.format(_("Confirm stopping of $0"), vdo.name), Teardown: TeardownMessage(usage), Action: { Title: _("Stop"), action: function () { return teardown_active_usage(client, usage) .then(function () { return vdo.stop(); }); } }, Inits: [ init_teardown_usage(client, usage) ] }); } else { return vdo.stop(); } } function delete_() { const usage = get_active_usage(client, block ? block.path : "/", _("delete")); if (usage.Blocking) { dialog_open({ Title: cockpit.format(_("$0 is in use"), vdo.name), Body: BlockingMessage(usage), }); return; } function wipe_with_teardown(block) { return block.Format("empty", { 'tear-down': { t: 'b', v: true } }).then(reload_systemd); } function teardown_configs() { if (block) { return wipe_with_teardown(block); } else { return vdo.start() .then(function () { return client.wait_for(() => client.slashdevs_block[vdo.dev]) .then(function (block) { return wipe_with_teardown(block) .catch(error => { // systemd might have mounted it, let's try unmounting const block_fsys = client.blocks_fsys[block.path]; if (block_fsys) { return block_fsys.Unmount({}) .then(() => wipe_with_teardown(block)); } else { return Promise.reject(error); } }); }); }); } } dialog_open({ Title: cockpit.format(_("Permanently delete $0?"), vdo.name), Body: TeardownMessage(usage), Action: { Title: _("Delete"), Danger: _("Deleting erases all data on a VDO device."), action: function () { return (teardown_active_usage(client, usage) .then(teardown_configs) .then(function () { return vdo.remove(); })); } }, Inits: [ init_teardown_usage(client, usage) ] }); } const vdo_card = new_card({ title: cockpit.format(_("VDO device $0"), vdo.name), next: next_card, page_location: ["vdo", vdo.name], page_name: block_short_name(backing_block), page_size: vdo.logical_size, job_path: backing_block.path, component: VDODetails, props: { client, vdo }, actions: [ (block ? { title: _("Stop"), action: stop } : { title: _("Start"), action: () => vdo.start() } ), { title: _("Delete"), action: delete_, danger: true } ], }); if (block) { make_block_page(parent, block, vdo_card); } else { new_page(parent, vdo_card); } } class VDODetails extends React.Component { constructor() { super(); this.poll_path = null; this.state = { stats: null }; } ensure_polling(enable) { const client = this.props.client; const vdo = this.props.vdo; const block = client.slashdevs_block[vdo.dev]; const path = enable && block ? vdo.dev : null; let buf = ""; if (this.poll_path === path) return; if (this.poll_path) { this.poll_process.close(); this.setState({ stats: null }); } if (path) this.poll_process = cockpit.spawn([client.legacy_vdo_overlay.python, "--", "-", path], { superuser: "require" }) .input(inotify_py + vdo_monitor_py) .stream((data) => { buf += data; const lines = buf.split("\n"); buf = lines[lines.length - 1]; if (lines.length >= 2) { this.setState({ stats: JSON.parse(lines[lines.length - 2]) }); } }); this.poll_path = path; } componentDidMount() { this.ensure_polling(true); } componentDidUpdate() { this.ensure_polling(true); } componentWillUnmount() { this.ensure_polling(false); } render() { const client = this.props.client; const vdo = this.props.vdo; const block = client.slashdevs_block[vdo.dev]; const backing_block = client.slashdevs_block[vdo.backing_dev]; function force_delete() { return vdo.force_remove(); } if (vdo.broken) { return ( {_("Remove device")} } /> ); } const alerts = []; if (backing_block && backing_block.Size > vdo.physical_size) alerts.push( {_("Grow to take all space")}} title={_("This VDO device does not use all of its backing device.")}> { cockpit.format(_("Only $0 of $1 are used."), fmt_size(vdo.physical_size), fmt_size(backing_block.Size))} ); function grow_logical() { dialog_open({ Title: cockpit.format(_("Grow logical size of $0"), vdo.name), Fields: [ SizeSlider("lsize", _("Logical size"), { max: 5 * vdo.logical_size, min: vdo.logical_size, round: 512, value: vdo.logical_size, allow_infinite: true }) ], Action: { Title: _("Grow"), action: function (vals) { if (vals.lsize > vdo.logical_size) return vdo.grow_logical(vals.lsize).then(() => { if (block && block.IdUsage == "filesystem") return cockpit.spawn(["fsadm", "resize", decode_filename(block.Device)], { superuser: "require", err: "message" }); }); } } }); } function fmt_perc(num) { if (num || num == 0) return num + "%"; else return "--"; } const stats = this.state.stats; const header = ( {_("Device file")} {vdo.dev} {_("Physical")} { stats ? cockpit.format(_("$0 data + $1 overhead used of $2 ($3)"), fmt_size(stats.dataBlocksUsed * stats.blockSize), fmt_size(stats.overheadBlocksUsed * stats.blockSize), fmt_size(vdo.physical_size), fmt_perc(stats.usedPercent)) : fmt_size(vdo.physical_size) } {_("Logical")} { stats ? cockpit.format(_("$0 used of $1 ($2 saved)"), fmt_size(stats.logicalBlocksUsed * stats.blockSize), fmt_size(vdo.logical_size), fmt_perc(stats.savingPercent)) : fmt_size(vdo.logical_size) }   {_("Grow")} {_("Index memory")} {fmt_size(vdo.index_mem * 1024 * 1024 * 1024)} {_("Compression")} vdo.set_compression(!vdo.compression)} /> {_("Deduplication")} vdo.set_deduplication(!vdo.deduplication)} /> ); return header; } }