public inbox for pve-devel@lists.proxmox.com
 help / color / mirror / Atom feed
From: Thomas Lamprecht <t.lamprecht@proxmox.com>
To: pve-devel@lists.proxmox.com
Subject: [PATCH container v3 21/38] config: add read-only meta property with the creation time
Date: Wed, 18 Nov 2026 05:37:33 +0100	[thread overview]
Message-ID: <20261118043817.1659212-22-t.lamprecht@proxmox.com> (raw)
In-Reply-To: <20261118043817.1659212-1-t.lamprecht@proxmox.com>

Containers need a place for information that the system records about
them, including the guest identity. Add a read-only 'meta' property
with the same 'ctime' member as for VMs. It is set when a container
gets created; a restore takes it from the backup and a clone from the
source.

'meta' is not accepted as a parameter by the create and update API
calls, and deleting or reverting it is rejected for every user,
including root. A manually queued change gets dropped with a warning
instead of applied. The target of a remote migration takes the property
from the source as it is, bypassing the generic update path, which
rejects read-only properties.

The config API returns 'meta' as a plain string, so that members from
newer versions do not fail the result validation of 'pct config'.
Older pve-container versions drop the property on their next config
write, and their strict parser for remote migrations rejects it after
the volumes were transferred.

Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com>
---

changes v2 -> v3:
* description of 'meta' says what it has
* tests for the independent fixes before the series (failed overwrite
  keeps the container, create over a container that appeared after the
  request started)

changes v1 -> v2:
* use the shared helper of pve-guest-common to drop a pending change of
  'meta'
* test script: use v5.36, mock the registration of used guest IDs
* wording of the commit message

 src/PVE/API2/LXC.pm         |   4 +
 src/PVE/API2/LXC/Config.pm  |  29 +-
 src/PVE/LXC/Config.pm       |  43 ++-
 src/test/Makefile           |   8 +-
 src/test/config_tests.pl    |  23 ++
 src/test/lifecycle_tests.pl | 613 ++++++++++++++++++++++++++++++++++++
 6 files changed, 702 insertions(+), 18 deletions(-)
 create mode 100755 src/test/lifecycle_tests.pl

diff --git a/src/PVE/API2/LXC.pm b/src/PVE/API2/LXC.pm
index be7d64e..753988c 100644
--- a/src/PVE/API2/LXC.pm
+++ b/src/PVE/API2/LXC.pm
@@ -427,6 +427,7 @@ __PACKAGE__->register_method({
         PVE::LXC::Config->update_pct_config($vmid, $conf, 0, $no_disk_param);
 
         $conf->{unprivileged} = 1 if $unprivileged;
+        $conf->{meta} = PVE::LXC::Config->new_meta_info_string() if !$restore;
 
         my $emsg = $restore ? "unable to restore CT $vmid -" : "unable to create CT $vmid -";
 
@@ -3317,6 +3318,8 @@ __PACKAGE__->register_method({
 
                     my $unprivileged = delete $new_conf->{unprivileged};
                     my $arch = delete $new_conf->{arch};
+                    # read-only for the update below, the source's values are kept as they are
+                    my $meta = delete $new_conf->{meta};
 
                     # TODO handle properly?
                     delete $new_conf->{snapshots};
@@ -3351,6 +3354,7 @@ __PACKAGE__->register_method({
                             $state->{vmid}, $conf, 0, $new_conf, [], [],
                         );
                         raise_param_exc($errors) if scalar(keys %$errors);
+                        $conf->{meta} = $meta if defined($meta);
                         PVE::LXC::Config->write_config($state->{vmid}, $conf);
                         PVE::LXC::update_lxc_config($vmid, $conf);
                     };
diff --git a/src/PVE/API2/LXC/Config.pm b/src/PVE/API2/LXC/Config.pm
index 805eac0..3d7529f 100644
--- a/src/PVE/API2/LXC/Config.pm
+++ b/src/PVE/API2/LXC/Config.pm
@@ -57,20 +57,23 @@ __PACKAGE__->register_method({
     },
     returns => {
         type => "object",
-        properties => PVE::LXC::Config->json_config_properties({
-            lxc => {
-                description =>
-                    "Array of lxc low-level configurations ([[key1, value1], [key2, value2] ...]).",
-                type => 'array',
-                items => { type => 'array', items => { type => 'string' } },
-                optional => 1,
-            },
-            digest => {
-                type => 'string',
-                description =>
-                    'SHA1 digest of configuration file. This can be used to prevent concurrent modifications.',
+        properties => PVE::LXC::Config->json_config_properties(
+            {
+                lxc => {
+                    description =>
+                        "Array of lxc low-level configurations ([[key1, value1], [key2, value2] ...]).",
+                    type => 'array',
+                    items => { type => 'array', items => { type => 'string' } },
+                    optional => 1,
+                },
+                digest => {
+                    type => 'string',
+                    description =>
+                        'SHA1 digest of configuration file. This can be used to prevent concurrent modifications.',
+                },
             },
-        }),
+            1,
+        ),
     },
     code => sub {
         my ($param) = @_;
diff --git a/src/PVE/LXC/Config.pm b/src/PVE/LXC/Config.pm
index b6eaf0b..c274e93 100644
--- a/src/PVE/LXC/Config.pm
+++ b/src/PVE/LXC/Config.pm
@@ -505,6 +505,15 @@ my $features_desc = {
     },
 };
 
+my $meta_info_fmt = {
+    ctime => {
+        type => 'integer',
+        description => "The guest creation timestamp as UNIX epoch time",
+        minimum => 0,
+        optional => 1,
+    },
+};
+
 my $confdesc = {
     lock => {
         optional => 1,
@@ -717,6 +726,13 @@ my $confdesc = {
             "Try to be more verbose. For now this only enables debug log-level on start.",
         default => 0,
     },
+    meta => {
+        optional => 1,
+        type => 'string',
+        format => $meta_info_fmt,
+        description =>
+            "Read-only meta-information about this container, for example its creation time.",
+    },
 };
 
 my $valid_lxc_conf_keys = {
@@ -1310,6 +1326,7 @@ sub queue_pct_config_changes {
     my $storage_cfg = PVE::Storage::config();
 
     foreach my $opt (@$revert) {
+        die "unable to revert read-only option: '$opt'\n" if $opt eq 'meta';
         delete $conf->{pending}->{$opt};
         $class->remove_from_pending_delete($conf, $opt); # also remove from deletion queue
     }
@@ -1318,6 +1335,7 @@ sub queue_pct_config_changes {
     my $modified = {}; # record modified options
 
     foreach my $opt (@$delete) {
+        die "unable to delete read-only option: '$opt'\n" if $opt eq 'meta';
         if (!defined($conf->{$opt}) && !defined($conf->{pending}->{$opt})) {
             warn "cannot delete '$opt' - not set in current configuration!\n";
             next;
@@ -1358,7 +1376,7 @@ sub queue_pct_config_changes {
             $value = PVE::LXC::verify_nameserver_list($value);
         } elsif ($opt eq 'searchdomain') {
             $value = PVE::LXC::verify_searchdomain_list($value);
-        } elsif ($opt eq 'unprivileged') {
+        } elsif ($opt eq 'unprivileged' || $opt eq 'meta') {
             die "unable to modify read-only option: '$opt'\n";
         } elsif ($opt eq 'tags') {
             $value = PVE::GuestHelpers::get_unique_tags($value);
@@ -1449,19 +1467,34 @@ sub check_type {
     }
 }
 
-# add JSON properties for create and set function
+# add JSON properties for create and set function, with $with_meta also the read-only 'meta' for
+# returning the config
 sub json_config_properties {
-    my ($class, $prop) = @_;
+    my ($class, $prop, $with_meta) = @_;
 
     foreach my $opt (keys %$confdesc) {
         next if $opt eq 'parent' || $opt eq 'snaptime';
+        next if $opt eq 'meta' && !$with_meta;
         next if $prop->{$opt};
         $prop->{$opt} = $confdesc->{$opt};
     }
 
+    if ($with_meta) {
+        # without its format, as a config written by a newer version can have unknown members
+        $prop->{meta} = { $prop->{meta}->%* };
+        delete $prop->{meta}->{format};
+    }
+
     return $prop;
 }
 
+# Returns the 'meta' property string for a newly created container.
+sub new_meta_info_string {
+    my ($class) = @_;
+
+    return PVE::JSONSchema::print_property_string({ ctime => int(time()) }, $meta_info_fmt);
+}
+
 my $parse_ct_mountpoint_full = sub {
     my ($class, $desc, $data, $noerr) = @_;
 
@@ -1653,6 +1686,8 @@ my $LXC_FASTPLUG_OPTIONS = {
 sub vmconfig_hotplug_pending {
     my ($class, $vmid, $conf, $storecfg, $selection, $errors) = @_;
 
+    $class->drop_pending_meta($conf);
+
     my $pid = PVE::LXC::find_lxc_pid($vmid);
     my $rootdir = "/proc/$pid/root";
 
@@ -1779,6 +1814,8 @@ sub vmconfig_hotplug_pending {
 sub vmconfig_apply_pending {
     my ($class, $vmid, $conf, $storecfg, $selection, $errors) = @_;
 
+    $class->drop_pending_meta($conf);
+
     my $add_apply_error = sub {
         my ($opt, $msg) = @_;
         my $err_msg = "unable to apply pending change $opt : $msg";
diff --git a/src/test/Makefile b/src/test/Makefile
index c1ff506..456dfb2 100644
--- a/src/test/Makefile
+++ b/src/test/Makefile
@@ -2,7 +2,8 @@ RUN_USERNS := lxc-usernsexec -m "u:0:`id -u`:1" -m "g:0:`id -g`:1" --
 
 all: test
 
-test: test_setup test_snapshot test_bindmount test_idmap test_config test_raw_config_write
+test: test_setup test_snapshot test_bindmount test_idmap test_config test_raw_config_write \
+	test_lifecycle
 
 test_setup: run_setup_tests.pl
 	if test -e /run/lock/sbuild; then \
@@ -30,5 +31,8 @@ test_config: config_tests.pl
 test_raw_config_write: raw_config_write_test.pl
 	./raw_config_write_test.pl
 
+test_lifecycle: lifecycle_tests.pl
+	./lifecycle_tests.pl
+
 clean:
-	rm -rf tmprootfs
+	rm -rf tmprootfs lifecycle-working
diff --git a/src/test/config_tests.pl b/src/test/config_tests.pl
index beb7e37..a37a9ad 100755
--- a/src/test/config_tests.pl
+++ b/src/test/config_tests.pl
@@ -175,4 +175,27 @@ subtest 'restore does not take over pending changes of the backup' => sub {
     }
 };
 
+subtest 'meta property' => sub {
+    like(PVE::LXC::Config->new_meta_info_string(), qr/^ctime=\d+$/, 'creation time is set');
+
+    my $raw = "hostname: ct100\nmeta: ctime=1700000000\n";
+    my $conf = PVE::LXC::Config::parse_pct_config('/lxc/100.conf', $raw, 1);
+    is($conf->{meta}, 'ctime=1700000000', 'meta is parsed');
+    is(PVE::LXC::Config::write_pct_config('/lxc/100.conf', $conf), $raw, 'meta is written');
+
+    $raw = "hostname: ct100\nmeta: ctime=1700000000,unknown=value\n";
+    my $warnings = '';
+    {
+        local $SIG{__WARN__} = sub { $warnings .= $_[0] };
+        $conf = PVE::LXC::Config::parse_pct_config('/lxc/100.conf', $raw);
+    }
+    like($warnings, qr/unable to parse value of 'meta'/, 'unknown member causes a warning');
+    is($conf->{meta}, 'ctime=1700000000,unknown=value', 'meta with unknown member is kept');
+    eval { PVE::LXC::Config::parse_pct_config('/lxc/100.conf', $raw, 1) };
+    like($@, qr/unable to parse value of 'meta'/, 'unknown member fails strict parsing');
+
+    ok(!exists(PVE::LXC::Config->json_config_properties({})->{meta}), 'meta cannot be set');
+    ok(exists(PVE::LXC::Config->json_config_properties({}, 1)->{meta}), 'meta is returned');
+};
+
 done_testing();
diff --git a/src/test/lifecycle_tests.pl b/src/test/lifecycle_tests.pl
new file mode 100755
index 0000000..01e0106
--- /dev/null
+++ b/src/test/lifecycle_tests.pl
@@ -0,0 +1,613 @@
+#!/usr/bin/perl
+
+# Runs API calls that create, restore, update and migrate containers against a fake cluster
+# filesystem in a working directory, with storage and container runtime operations mocked.
+
+use v5.36;
+
+use lib qw(..);
+
+# The API modules load modules of pve-ha-manager, which is not a build dependency, so stub them. Tests
+# that call into them mock the functions they need.
+BEGIN {
+    $INC{'PVE/HA/Config.pm'} = $INC{'PVE/HA/Env/PVE2.pm'} = __FILE__;
+}
+
+use File::Path qw(make_path remove_tree);
+use JSON;
+use Socket qw(AF_UNIX SOCK_STREAM PF_UNSPEC);
+use Test::MockModule;
+use Test::More;
+
+use PVE::Cluster;
+use PVE::GuestHelpers;
+use PVE::INotify;
+use PVE::JSONSchema;
+use PVE::Tools qw(file_get_contents file_set_contents);
+
+use PVE::LXC;
+use PVE::LXC::Config;
+use PVE::LXC::Create;
+
+use PVE::API2::LXC;
+use PVE::API2::LXC::Config;
+
+my $WORKDIR = 'lifecycle-working';
+my $NODENAME = PVE::INotify::nodename();
+my $BACKUP_VOLID = 'local:backup/vzdump-lxc-100-2026_01_01-00_00_00.tar.zst';
+
+remove_tree($WORKDIR);
+make_path("$WORKDIR/lock");
+
+# Fake cluster filesystem
+
+my sub cfs_file($path) {
+    return "$WORKDIR/cfs/$path";
+}
+
+my sub ct_config_path($vmid, $node = undef) {
+    return "nodes/" . ($node // $NODENAME) . "/lxc/$vmid.conf";
+}
+
+my sub write_raw_config($vmid, $raw, $node = undef) {
+    my $file = cfs_file(ct_config_path($vmid, $node));
+    make_path($file =~ s|/[^/]+$||r);
+    file_set_contents($file, $raw);
+}
+
+my sub read_raw_config($vmid, $node = undef) {
+    my $file = cfs_file(ct_config_path($vmid, $node));
+    return -f $file ? file_get_contents($file) : undef;
+}
+
+# VMIDs whose container config still existed when their firewall config got removed
+my $vmfw_removed_reserved = {};
+
+my sub reset_configs {
+    remove_tree("$WORKDIR/cfs", "$WORKDIR/rootfs");
+    $vmfw_removed_reserved = {};
+}
+
+my $storage_cfg = {
+    ids => {
+        local => {
+            type => 'dir',
+            path => '/var/lib/vz',
+            content => { rootdir => 1, images => 1, backup => 1, vztmpl => 1 },
+        },
+    },
+};
+
+# recording used guest IDs needs the cluster filesystem and is not what gets tested here
+my $guest_id_module = Test::MockModule->new('PVE::GuestID');
+$guest_id_module->mock(register_used_id => sub { return; });
+
+my $cluster_module = Test::MockModule->new('PVE::Cluster');
+$cluster_module->mock(
+    cfs_update => sub { },
+    check_cfs_quorum => sub { },
+    check_node_exists => sub { },
+    get_config => sub {
+        my ($path) = @_;
+        my $file = cfs_file($path);
+        return -f $file ? file_get_contents($file) : undef;
+    },
+    cfs_read_file => sub {
+        my ($path) = @_;
+        die "unexpected read of '$path'\n" if $path !~ m|^nodes/[^/]+/lxc/\d+\.conf$|;
+        my $file = cfs_file($path);
+        return undef if !-f $file;
+        return PVE::LXC::Config::parse_pct_config("/etc/pve/$path", file_get_contents($file));
+    },
+    cfs_write_file => sub {
+        my ($path, $conf) = @_;
+        die "unexpected write of '$path'\n" if $path !~ m|^nodes/[^/]+/lxc/\d+\.conf$|;
+        my $raw = PVE::LXC::Config::write_pct_config("/etc/pve/$path", $conf);
+        my $file = cfs_file($path);
+        make_path($file =~ s|/[^/]+$||r);
+        file_set_contents($file, $raw);
+    },
+    check_vmid_unused => sub {
+        my ($vmid, $noerr) = @_;
+        return 1 if !-f cfs_file(ct_config_path($vmid));
+        return undef if $noerr;
+        die "CT $vmid already exists on node '$NODENAME'\n";
+    },
+);
+
+my $api_module = Test::MockModule->new('PVE::API2::LXC');
+$api_module->mock(
+    cfs_read_file => sub {
+        my ($path) = @_;
+        die "unexpected read of '$path'\n" if $path ne 'storage.cfg';
+        return $storage_cfg;
+    },
+);
+
+my $config_module = Test::MockModule->new('PVE::LXC::Config');
+$config_module->mock(
+    config_file => sub {
+        my ($class, $vmid, $node) = @_;
+        return cfs_file(ct_config_path($vmid, $node));
+    },
+    config_file_lock => sub {
+        my ($class, $vmid) = @_;
+        return "$WORKDIR/lock/pve-config-$vmid.lock";
+    },
+);
+
+my $repl_config_module = Test::MockModule->new('PVE::ReplicationConfig');
+$repl_config_module->mock(
+    new => sub { return bless {}, 'PVE::ReplicationConfig' },
+    check_for_existing_jobs => sub { return undef },
+);
+
+# Fake environment, records task output
+
+my $task_log = '';
+
+package PVE::LXC::Test::RPCEnvironment {
+
+    sub new($class, $user) {
+        return bless { user => $user, type => 'cli' }, $class;
+    }
+
+    sub get_user { return $_[0]->{user} }
+    sub check { return 1 }
+    sub check_vm_perm { return 1 }
+    sub check_pool_exist { return 1 }
+
+    sub warn($self, $msg) {
+        $task_log .= "WARN: $msg\n";
+    }
+
+    sub fork_worker($self, $type, $id, $user, $function, @) {
+        my $upid = "UPID:$NODENAME:$type:$id";
+        $function->($upid);
+        return $upid;
+    }
+}
+
+my $rpcenv = PVE::LXC::Test::RPCEnvironment->new('root@pam');
+
+my $rpcenv_module = Test::MockModule->new('PVE::RPCEnvironment');
+$rpcenv_module->mock(get => sub { return $rpcenv });
+
+my $restenv_module = Test::MockModule->new('PVE::RESTEnvironment');
+$restenv_module->mock(
+    log_warn => sub {
+        my ($msg) = @_;
+        chomp($msg);
+        $task_log .= "WARN: $msg\n";
+    },
+);
+
+# Runs $code like a task, with its output going to the task log. Returns the error, if any.
+my sub run_task($code) {
+    $task_log = '';
+    my $output = '';
+    eval {
+        local *STDOUT;
+        open(STDOUT, '>', \$output) or die "unable to capture output - $!\n";
+        local $SIG{__WARN__} = sub { $output .= "WARN: $_[0]" };
+        $code->();
+    };
+    my $err = $@;
+    $task_log = $output . $task_log;
+
+    return $err;
+}
+
+# Fake storage and container runtime
+
+my $backup_raw_config;
+
+my $storage_module = Test::MockModule->new('PVE::Storage');
+$storage_module->mock(
+    config => sub { return $storage_cfg },
+    activate_storage => sub { },
+    activate_volumes => sub { },
+    deactivate_volumes => sub { },
+    check_volume_access => sub { },
+    storage_check_enabled => sub {
+        my ($cfg, $storeid) = @_;
+        return $storage_cfg->{ids}->{$storeid};
+    },
+    storage_config => sub {
+        my ($cfg, $storeid) = @_;
+        return $storage_cfg->{ids}->{$storeid} // die "storage '$storeid' does not exist\n";
+    },
+    storage_has_feature => sub { return 0 },
+    get_bandwidth_limit => sub { return undef },
+);
+
+my $lxc_module = Test::MockModule->new('PVE::LXC');
+$lxc_module->mock(
+    check_running => sub { return 0 },
+    create_disks => sub {
+        my ($storecfg, $vmid, $settings, $conf) = @_;
+        my $vollist = [];
+        for my $ms (sort keys %$settings) {
+            my $volid = "local:$vmid/vm-$vmid-disk-$ms.raw";
+            $conf->{$ms} = "$volid,size=4G";
+            push @$vollist, $volid;
+        }
+        return $vollist;
+    },
+    destroy_disks => sub { },
+    destroy_lxc_container => sub {
+        my ($storecfg, $vmid, $conf, $replacement_conf) = @_;
+        if (defined($replacement_conf)) {
+            PVE::LXC::Config->write_config($vmid, $replacement_conf);
+        } else {
+            PVE::LXC::Config->destroy_config($vmid);
+        }
+    },
+    mount_all => sub {
+        my ($vmid) = @_;
+        my $rootdir = "$WORKDIR/rootfs/$vmid";
+        make_path($rootdir);
+        return $rootdir;
+    },
+    umount_all => sub { },
+    create_ifaces_ipams_ips => sub { },
+    delete_ifaces_ipams_ips => sub { },
+    update_lxc_config => sub { },
+);
+
+my $create_module = Test::MockModule->new('PVE::LXC::Create');
+$create_module->mock(
+    archive_is_oci_format => sub { return 0 },
+    recover_config => sub {
+        my ($storecfg, $volid, $vmid) = @_;
+        my $conf = PVE::LXC::Config::parse_pct_config("/lxc/$vmid.conf", $backup_raw_config);
+        delete $conf->{snapshots};
+        my $mp_param = {};
+        PVE::LXC::Config->foreach_volume($conf,
+            sub { $mp_param->{ $_[0] } = $conf->{ $_[0] } });
+        return wantarray ? ($conf, $mp_param) : $conf;
+    },
+    restore_archive => sub {
+        my ($storecfg, $archive, $rootdir, $conf) = @_;
+        if (defined($backup_raw_config)) {
+            make_path("$rootdir/etc/vzdump");
+            file_set_contents("$rootdir/etc/vzdump/pct.conf", $backup_raw_config);
+        }
+    },
+);
+
+my $setup_module = Test::MockModule->new('PVE::LXC::Setup');
+$setup_module->mock(new => sub { return bless {}, 'PVE::LXC::Test::Setup' });
+
+package PVE::LXC::Test::Setup {
+    sub post_create_hook { }
+    sub post_restore_hook { }
+    sub post_clone_hook { }
+}
+
+my $firewall_module = Test::MockModule->new('PVE::Firewall');
+$firewall_module->mock(
+    remove_vmfw_conf => sub {
+        my ($vmid) = @_;
+        $vmfw_removed_reserved->{$vmid}++ if defined(read_raw_config($vmid));
+    },
+);
+
+my $access_control_module = Test::MockModule->new('PVE::AccessControl');
+$access_control_module->mock(assemble_tunnel_ticket => sub { return 'ticket' });
+
+# API call helpers
+
+my sub create_ct($vmid, $param = undef) {
+    return run_task(sub {
+        PVE::API2::LXC->create_vm({
+            node => $NODENAME,
+            vmid => $vmid,
+            ostemplate => 'local:vztmpl/debian-13-standard_13.1-2_amd64.tar.zst',
+            hostname => "ct$vmid",
+            ($param // {})->%*,
+        });
+    });
+}
+
+my sub restore_ct($vmid, $param = undef) {
+    return run_task(sub {
+        PVE::API2::LXC->create_vm({
+            node => $NODENAME,
+            vmid => $vmid,
+            ostemplate => $BACKUP_VOLID,
+            restore => 1,
+            ($param // {})->%*,
+        });
+    });
+}
+
+my sub update_ct($vmid, $param) {
+    return run_task(sub {
+        PVE::API2::LXC::Config->update_vm({ node => $NODENAME, vmid => $vmid, $param->%* });
+    });
+}
+
+# Runs the migration tunnel for $vmid with the commands @commands, which are sent at once, and
+# returns the error of the task, if any, and the replies.
+my sub run_mtunnel($vmid, @commands) {
+    socketpair(my $tunnel_end, my $client_end, AF_UNIX, SOCK_STREAM, PF_UNSPEC)
+        or die "socketpair failed - $!\n";
+    for my $command (@commands) {
+        print $client_end JSON::encode_json($command) . "\n";
+    }
+    $client_end->flush();
+    shutdown($client_end, 1);
+
+    my $socket_module = Test::MockModule->new('IO::Socket::UNIX');
+    $socket_module->mock(
+        new => sub { return bless { conn => $tunnel_end }, 'PVE::LXC::Test::Socket' });
+
+    my $err = run_task(sub { PVE::API2::LXC->mtunnel({ node => $NODENAME, vmid => $vmid }) });
+
+    close($tunnel_end);
+    my $replies = [map { JSON::decode_json($_) } <$client_end>];
+    close($client_end);
+
+    return ($err, $replies);
+}
+
+package PVE::LXC::Test::Socket {
+    sub accept { return $_[0]->{conn} }
+}
+
+my $INCOMING_CONFIG = <<~'EOF';
+    arch: amd64
+    hostname: incoming
+    memory: 1024
+    meta: ctime=1600000000
+    ostype: debian
+    rootfs: local:300/vm-300-disk-0.raw,size=4G
+    unprivileged: 1
+    EOF
+
+my sub backup_config($meta = undef) {
+    my $raw = <<~'EOF';
+        arch: amd64
+        hostname: backup
+        memory: 2048
+        ostype: debian
+        rootfs: local:100/vm-100-disk-0.raw,size=8G
+        unprivileged: 1
+        EOF
+    $raw .= "meta: $meta\n" if defined($meta);
+
+    return $raw;
+}
+
+my sub existing_config($meta = undef) {
+    my $raw = <<~'EOF';
+        arch: amd64
+        hostname: existing
+        memory: 512
+        ostype: debian
+        rootfs: local:200/vm-200-disk-0.raw,size=4G
+        unprivileged: 1
+        EOF
+    $raw .= "meta: $meta\n" if defined($meta);
+
+    return $raw;
+}
+
+# Returns the members of the 'meta' property in the config of $vmid.
+my sub meta_of($vmid) {
+    my $conf = PVE::LXC::Config->load_config($vmid);
+
+    return { map { split(/=/, $_, 2) } split(/,/, $conf->{meta} // '') };
+}
+
+# Tests
+
+subtest 'meta cannot be changed through the API' => sub {
+    reset_configs();
+    write_raw_config(200, existing_config('ctime=1500000000'));
+    my $raw = read_raw_config(200);
+
+    for my $user ('root@pam', 'admin@pve') {
+        $rpcenv = PVE::LXC::Test::RPCEnvironment->new($user);
+
+        my $err = update_ct(200, { meta => 'ctime=1' });
+        like($err, qr/meta: property is not defined in schema/, "$user cannot set meta");
+
+        $err = update_ct(200, { delete => 'meta' });
+        like($err, qr/unable to delete read-only option: 'meta'/, "$user cannot delete meta");
+
+        $err = update_ct(200, { revert => 'meta' });
+        like($err, qr/unable to revert read-only option: 'meta'/, "$user cannot revert meta");
+
+        $err = create_ct(201, { meta => 'ctime=1' });
+        like($err, qr/meta: property is not defined in schema/,
+            "$user cannot create with meta");
+
+        $err = restore_ct(200, { force => 1, meta => 'ctime=1' });
+        like(
+            $err,
+            qr/meta: property is not defined in schema/,
+            "$user cannot restore with meta",
+        );
+    }
+    $rpcenv = PVE::LXC::Test::RPCEnvironment->new('root@pam');
+
+    is(read_raw_config(200), $raw, 'config is unchanged');
+    ok(!defined(read_raw_config(201)), 'no container got created');
+
+    my $conf = PVE::LXC::Config->load_config(200);
+    eval { PVE::LXC::Config->update_pct_config(200, $conf, 0, { meta => 'ctime=1' }, [], []) };
+    like($@, qr/unable to modify read-only option: 'meta'/, 'update cannot set meta');
+
+    write_raw_config(200, existing_config());
+    my $err = update_ct(200, { delete => 'meta' });
+    like($err, qr/unable to delete read-only option: 'meta'/,
+        'meta cannot be deleted if unset');
+};
+
+subtest 'pending changes of meta are dropped' => sub {
+    my $raw = existing_config('ctime=1500000000') . <<~'EOF';
+
+        [pve:pending]
+        delete: meta
+        meta: ctime=1
+        EOF
+
+    reset_configs();
+    write_raw_config(200, $raw);
+    my $err = update_ct(200, { hostname => 'changed' });
+    is($err, '', 'update succeeds');
+    like($task_log, qr/ignoring pending change of read-only option 'meta'/, 'drop is logged');
+    my $conf = PVE::LXC::Config->load_config(200);
+    is(meta_of(200)->{ctime}, 1500000000, 'ctime is kept');
+    is_deeply($conf->{pending}, {}, 'pending change of meta is dropped');
+
+    for my $pending ('meta: ctime=1', 'delete: meta') {
+        $conf = PVE::LXC::Config::parse_pct_config(
+            '/lxc/200.conf',
+            existing_config('ctime=1500000000') . "\n[pve:pending]\n$pending\n",
+        );
+        {
+            local $SIG{__WARN__} = sub { };
+            PVE::LXC::Config->vmconfig_apply_pending(200, $conf, $storage_cfg);
+        }
+        is($conf->{meta}, 'ctime=1500000000', "applying '$pending' keeps meta");
+        is_deeply($conf->{pending}, {}, "applying drops '$pending'");
+    }
+
+    $conf = PVE::LXC::Config::parse_pct_config('/lxc/200.conf', $raw);
+    my $cgroup_module = Test::MockModule->new('PVE::LXC::CGroup');
+    $cgroup_module->mock(new => sub { return bless {}, 'PVE::LXC::CGroup' });
+    $lxc_module->mock(find_lxc_pid => sub { return 1 });
+    {
+        local $SIG{__WARN__} = sub { };
+        PVE::LXC::Config->vmconfig_hotplug_pending(200, $conf, $storage_cfg, undef, {});
+    }
+    $lxc_module->unmock('find_lxc_pid');
+    is($conf->{meta}, 'ctime=1500000000', 'hotplugging keeps meta');
+    is_deeply($conf->{pending}, {}, 'hotplugging drops the pending change of meta');
+};
+
+subtest 'meta with members unknown to this version can be read' => sub {
+    reset_configs();
+    write_raw_config(200, existing_config('ctime=1500000000,future=value'));
+
+    my $info = PVE::API2::LXC::Config->map_method_by_name('vm_config');
+    my $conf = eval {
+        local $SIG{__WARN__} = sub { };
+        PVE::API2::LXC::Config->handle($info, { node => $NODENAME, vmid => 200 }, 1);
+    };
+    is($@, '', 'config passes the result verification');
+    is($conf->{meta}, 'ctime=1500000000,future=value', 'meta is returned as it is');
+};
+
+subtest 'create sets the creation time' => sub {
+    reset_configs();
+
+    my $before = time();
+    my $err = create_ct(201);
+    my $after = time();
+    is($err, '', 'create succeeds');
+
+    my $ctime = meta_of(201)->{ctime};
+    ok($ctime >= $before && $ctime <= $after, 'ctime is the time of the create');
+};
+
+subtest 'restore keeps the meta information of the backup' => sub {
+    reset_configs();
+
+    $backup_raw_config = backup_config('ctime=1400000000');
+    my $err = restore_ct(201);
+    is($err, '', 'restore to a free VMID succeeds');
+    is(meta_of(201)->{ctime}, 1400000000, 'backup ctime is kept');
+
+    write_raw_config(200, existing_config('ctime=1500000000'));
+    $err = restore_ct(200, { force => 1 });
+    is($err, '', 'restore over an existing container succeeds');
+    is(meta_of(200)->{ctime}, 1400000000, 'backup ctime is used');
+};
+
+subtest 'restore over a container keeps it if replacing it fails early' => sub {
+    $backup_raw_config = backup_config('ctime=1400000000');
+
+    my $kept = sub {
+        my ($name, $expected_err) = @_;
+
+        my $err = restore_ct(200, { force => 1 });
+        like($err, $expected_err, "$name: restore fails");
+        ok(!$vmfw_removed_reserved->{200}, "$name: firewall config is kept");
+        ok(defined(read_raw_config(200)), "$name: config is kept") or return;
+        my $conf = PVE::LXC::Config->load_config(200);
+        is($conf->{hostname}, 'existing', "$name: config is the one of the container");
+        is($conf->{rootfs}, 'local:200/vm-200-disk-0.raw,size=4G', "$name: volume is kept");
+        ok(!defined($conf->{lock}), "$name: lock is removed");
+    };
+
+    my $mocked_create_disks = \&PVE::LXC::create_disks;
+    $lxc_module->mock(create_disks => sub { die "unable to allocate volume - storage full\n" });
+    reset_configs();
+    write_raw_config(200, existing_config('ctime=1500000000'));
+    $kept->('allocation fails', qr/storage full/);
+    $lxc_module->mock(create_disks => $mocked_create_disks);
+
+    my $mocked_destroy = \&PVE::LXC::destroy_lxc_container;
+    $lxc_module->mock(
+        destroy_lxc_container => sub {
+            my ($storecfg, $vmid, $conf) = @_;
+            # like the real function, which checks this before it removes anything
+            die "base volume 'local:200/base-200-disk-0.raw' is still in use by linked clone\n"
+                if $conf->{template};
+            return $mocked_destroy->(@_);
+        },
+    );
+    reset_configs();
+    write_raw_config(200, existing_config('ctime=1500000000') . "template: 1\n");
+    $kept->('template with linked clones', qr/still in use by linked clone/);
+    $lxc_module->mock(destroy_lxc_container => $mocked_destroy);
+};
+
+subtest 'create refuses a container created after the call started' => sub {
+    my $raw = existing_config('ctime=1500000000') =~ s/^hostname: existing$/hostname: other/mr;
+    reset_configs();
+
+    my $mocked_activate = \&PVE::Storage::activate_storage;
+    $storage_module->mock(
+        activate_storage => sub {
+            # another task creates CT 200 between the checks and the reservation
+            write_raw_config(200, $raw) if !defined(read_raw_config(200));
+            return $mocked_activate->(@_);
+        },
+    );
+    # like the guest list of PVE::Cluster, which only changes with cfs_update at the call start
+    my $mocked_unused = \&PVE::Cluster::check_vmid_unused;
+    $cluster_module->mock(check_vmid_unused => sub { return 1 });
+
+    my $err = create_ct(200);
+    $cluster_module->mock(check_vmid_unused => $mocked_unused);
+    $storage_module->mock(activate_storage => $mocked_activate);
+
+    like($err, qr/CT 200 already exists/, 'create is refused');
+    is(read_raw_config(200), $raw, 'container is unchanged');
+};
+
+subtest 'remote migration keeps the meta information of the source' => sub {
+    reset_configs();
+
+    my ($err, $replies) = run_mtunnel(
+        300,
+        { cmd => 'config', conf => $INCOMING_CONFIG },
+        { cmd => 'quit', cleanup => 0 },
+    );
+    is($err, '', 'tunnel exits normally') or diag(explain($replies), $task_log);
+    ok($replies->[0]->{success}, 'config command succeeds');
+
+    my $conf = PVE::LXC::Config->load_config(300);
+    is(meta_of(300)->{ctime}, 1600000000, 'source ctime is kept');
+    is($conf->{hostname}, 'incoming', 'other options are applied');
+    is($conf->{lock}, 'migrate', 'config is locked for the migration');
+};
+
+remove_tree($WORKDIR);
+
+done_testing();
-- 
2.47.3





  parent reply	other threads:[~2026-11-18  4:44 UTC|newest]

Thread overview: 42+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-18  4:37 [PATCH cluster/guest-common/qemu-server/container/manager/docs v3 00/38] fix #7846: guest identity (uid) and cluster ID Thomas Lamprecht
2026-11-18  4:37 ` [PATCH cluster v3 01/38] pmxcfs: reject changes to the cluster ID file from user space Thomas Lamprecht
2026-11-18  4:37 ` [PATCH cluster v3 02/38] pmxcfs: generate a cluster ID on standalone nodes Thomas Lamprecht
2026-11-18  4:37 ` [PATCH cluster v3 03/38] pmxcfs: dfsm: add a callback that runs once all members are in sync Thomas Lamprecht
2026-11-18  4:37 ` [PATCH cluster v3 04/38] pmxcfs: quorum: pass the corosync membership to an optional listener Thomas Lamprecht
2026-11-18  4:37 ` [PATCH cluster v3 05/38] pmxcfs: confdb: call an optional listener when the nodes get published Thomas Lamprecht
2026-11-18  4:37 ` [PATCH cluster v3 06/38] pmxcfs: dcdb: generate the cluster ID once the cluster is in sync Thomas Lamprecht
2026-11-18  4:37 ` [PATCH cluster v3 07/38] cluster: add helper to read the cluster ID Thomas Lamprecht
2026-11-18  4:37 ` [PATCH cluster v3 08/38] pmxcfs: allow removing the cluster ID file in forced local mode Thomas Lamprecht
2026-11-18  4:37 ` [PATCH guest-common v3 09/38] guest identity: add helpers for the guest uid and registration time Thomas Lamprecht
2026-11-18  4:37 ` [PATCH guest-common v3 10/38] abstract config: assign a guest identity and keep it on config writes Thomas Lamprecht
2026-11-18  4:37 ` [PATCH guest-common v3 11/38] abstract config: let the VMID reservation return the previous state Thomas Lamprecht
2026-11-18  4:37 ` [PATCH guest-common v3 12/38] guest identity: allow taking over a uid that is unused in the cluster Thomas Lamprecht
2026-11-18  4:37 ` [PATCH guest-common v3 13/38] migrate: add shared helpers for the identity command of the migration tunnel Thomas Lamprecht
2026-11-18  4:37 ` [PATCH qemu-server v3 14/38] api: restore: release the VMID if a restore to an unused VMID fails Thomas Lamprecht
2026-11-18  4:37 ` [PATCH qemu-server v3 15/38] api: migrate, clone: refuse targets that would drop the guest identity Thomas Lamprecht
2026-11-18  4:37 ` [PATCH qemu-server v3 16/38] fix #7846: config: add a guest identity to the 'meta' property Thomas Lamprecht
2026-11-18  4:37 ` [PATCH qemu-server v3 17/38] restore: take over the guest uid from the backup where possible Thomas Lamprecht
2026-11-18  4:37 ` [PATCH qemu-server v3 18/38] api: remote migration: take over the guest uid from the source Thomas Lamprecht
2026-11-18  4:37 ` [PATCH qemu-server v3 19/38] api: status: return the guest uid Thomas Lamprecht
2026-11-18  4:37 ` [PATCH qemu-server v3 20/38] tests: remote migration: check a failed command and an early tunnel end Thomas Lamprecht
2026-11-18  4:37 ` Thomas Lamprecht [this message]
2026-11-18  4:37 ` [PATCH container v3 22/38] fix #7846: config: add a guest identity to the 'meta' property Thomas Lamprecht
2026-11-18  4:37 ` [PATCH container v3 23/38] api: migrate, clone: refuse targets that would drop the guest identity Thomas Lamprecht
2026-11-18  4:37 ` [PATCH container v3 24/38] restore: take over the guest uid from the backup where possible Thomas Lamprecht
2026-11-18  4:37 ` [PATCH container v3 25/38] restore: refuse overwriting a container with another guest's backup Thomas Lamprecht
2026-11-18  4:37 ` [PATCH container v3 26/38] test: remote migration: check the cleanup of the target after failures Thomas Lamprecht
2026-11-18  4:37 ` [PATCH container v3 27/38] api: remote migration: take over the guest uid from the source Thomas Lamprecht
2026-11-18  4:37 ` [PATCH container v3 28/38] api: status: return the guest uid Thomas Lamprecht
2026-11-18  4:37 ` [PATCH manager v3 29/38] api: cluster resources: add guest uid and registration time Thomas Lamprecht
2026-11-18  4:37 ` [PATCH manager v3 30/38] api: cluster status: add cluster ID Thomas Lamprecht
2026-11-18  4:37 ` [PATCH manager v3 31/38] ui: restore: allow overwriting a guest with a backup of another guest Thomas Lamprecht
2026-11-18  4:37 ` [PATCH manager v3 32/38] ui: migrate: refuse target nodes that would drop the guest identity Thomas Lamprecht
2026-11-18  4:37 ` [PATCH manager v3 33/38] ui: guest summary: show " Thomas Lamprecht
2026-11-18  4:37 ` [PATCH manager v3 34/38] api: bulk migrate: refuse targets that would drop " Thomas Lamprecht
2026-11-18  4:37 ` [PATCH docs v3 35/38] vzdump: describe the guest identity of VMs and containers Thomas Lamprecht
2026-11-18  4:37 ` [PATCH docs v3 36/38] pvecm: document the cluster ID and how to get a new one Thomas Lamprecht
2026-11-18  4:37 ` [PATCH docs v3 37/38] qm: configuration: describe the read-only meta property Thomas Lamprecht
2026-11-18  4:37 ` [PATCH docs v3 38/38] pct: " Thomas Lamprecht
2026-11-18 13:49 ` [PATCH cluster/guest-common/qemu-server/container/manager/docs v3 00/38] fix #7846: guest identity (uid) and cluster ID Dominik Csapak
2026-11-18 14:13   ` Thomas Lamprecht
2026-11-19 10:38 ` superseded: " Thomas Lamprecht

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20261118043817.1659212-22-t.lamprecht@proxmox.com \
    --to=t.lamprecht@proxmox.com \
    --cc=pve-devel@lists.proxmox.com \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox
Service provided by Proxmox Server Solutions GmbH | Privacy | Legal