[pve-manager.git] / bin / test / ReplicationTestEnv.pm

package ReplicationTestEnv;

use strict;
use warnings;
use JSON;
use Clone 'clone';
use File::Basename;

use lib ('.', '../..');

use Data::Dumper;

use PVE::INotify;
use PVE::Cluster;
use PVE::Storage;
use PVE::ReplicationConfig;
use PVE::ReplicationState;
use PVE::API2::Replication;
use PVE::Replication;
use PVE::QemuConfig;
use PVE::LXC::Config;


use Test::MockModule;

our $mocked_nodename = 'node1';

our $mocked_replication_jobs = {};

my $pve_replication_config_module = Test::MockModule->new('PVE::ReplicationConfig');
my $pve_replication_state_module = Test::MockModule->new('PVE::ReplicationState');

our $mocked_vm_configs = {};

our $mocked_ct_configs = {};

my $mocked_get_members = sub {
    return {
	node1 => { online => 1 },
	node2 => { online => 1 },
	node3 => { online => 1 },
    };
};

my $mocked_vmlist = sub {
    my $res = {};

    foreach my $id (keys %$mocked_ct_configs) {
	my $d = $mocked_ct_configs->{$id};
	$res->{$id} = { 'type' => 'lxc', 'node' => $d->{node}, 'version' => 1 };
    }
    foreach my $id (keys %$mocked_vm_configs) {
	my $d = $mocked_vm_configs->{$id};
	$res->{$id} = { 'type' => 'qemu', 'node' => $d->{node}, 'version' => 1 };
    }

    return { 'ids' => $res };
};

my $mocked_get_ssh_info  = sub {
    my ($node, $network_cidr) = @_;

    return { node => $node };
};

my $mocked_ssh_info_to_command = sub {
    my ($info, @extra_options) = @_;

    return ['fake_ssh', $info->{name}, @extra_options];
};

my $statefile = ".mocked_repl_state";

unlink $statefile;
$PVE::ReplicationState::state_path = $statefile;
$PVE::ReplicationState::state_lock = ".mocked_repl_state_lock";
$PVE::API2::Replication::pvesr_lock_path = ".mocked_pvesr_lock";
$PVE::GuestHelpers::lockdir = ".mocked_pve-manager_lock";

if (!mkdir($PVE::GuestHelpers::lockdir) && !$!{EEXIST}) {
    # If we cannot create the guest helper lockdir we'll loop endlessly, so die
    # if it fails.
    die "mkdir($PVE::GuestHelpers::lockdir): $!\n";
}

my $pve_cluster_module = Test::MockModule->new('PVE::Cluster');

my $pve_inotify_module = Test::MockModule->new('PVE::INotify');

my $mocked_qemu_load_conf = sub {
    my ($class, $vmid, $node) = @_;

    $node = $mocked_nodename if !$node;

    my $conf = $mocked_vm_configs->{$vmid};

    die "no such vm '$vmid'" if !defined($conf);
    die "vm '$vmid' on wrong node" if $conf->{node} ne $node;

    return $conf;
};

my $pve_qemuserver_module = Test::MockModule->new('PVE::QemuServer');

my $pve_qemuconfig_module = Test::MockModule->new('PVE::QemuConfig');

my $mocked_lxc_load_conf = sub {
    my ($class, $vmid, $node) = @_;

    $node = $mocked_nodename if !$node;

    my $conf = $mocked_ct_configs->{$vmid};

    die "no such ct '$vmid'" if !defined($conf);
    die "ct '$vmid' on wrong node" if $conf->{node} ne $node;

    return $conf;
};

my $pve_lxc_config_module = Test::MockModule->new('PVE::LXC::Config');

my $mocked_replication_config_new = sub {

    my $res = clone($mocked_replication_jobs);

    return bless { ids => $res }, 'PVE::ReplicationConfig';
};

my $mocked_storage_config = {
    ids => {
	local => {
	    type => 'dir',
	    shared => 0,
	    content => {
		'iso' => 1,
		'backup' => 1,
	    },
	    path => "/var/lib/vz",
	},
	'local-zfs' => {
	    type => 'zfspool',
	    pool => 'nonexistent-testpool',
	    shared => 0,
	    content => {
		'images' => 1,
		'rootdir' => 1
	    },
	},
    },
};

my $pve_storage_module = Test::MockModule->new('PVE::Storage');

my $mocked_storage_content = {};

sub register_mocked_volid {
    my ($volid, $snapname) = @_;

    my ($storeid, $volname) = PVE::Storage::parse_volume_id($volid);
    my $scfg = $mocked_storage_config->{ids}->{$storeid} ||
	die "no such storage '$storeid'\n";

    my $d = $mocked_storage_content->{$storeid}->{$volname} //= {};

    $d->{$snapname} = 1 if $snapname;
}

my $mocked_volume_snapshot_list = sub {
    my ($cfg, $volid, $prefix) = @_;

    my ($storeid, $volname) = PVE::Storage::parse_volume_id($volid);
    my $snaps = [];

    if (my $d = $mocked_storage_content->{$storeid}->{$volname}) {
	$snaps = [keys %$d];
    }

    return $snaps;
};

my $mocked_volume_snapshot = sub {
    my ($cfg, $volid, $snap) = @_;

    my ($storeid, $volname) = PVE::Storage::parse_volume_id($volid);

    my $d = $mocked_storage_content->{$storeid}->{$volname};
    die "no such volid '$volid'\n" if !$d;
    $d->{$snap} = 1;
};

my $mocked_volume_snapshot_delete = sub {
    my ($cfg, $volid, $snap, $running) = @_;

    my ($storeid, $volname) = PVE::Storage::parse_volume_id($volid);
    my $d = $mocked_storage_content->{$storeid}->{$volname};
    die "no such volid '$volid'\n" if !$d;
    delete $d->{$snap} || die "no such snapshot '$snap' on '$volid'\n";
};

my $pve_replication_module = Test::MockModule->new('PVE::Replication');

my $mocked_job_logfile_name = sub {
    my ($jobid) = @_;

    return ".mocked_replication_log_$jobid";
};

my $mocked_log_time = 0;

my $mocked_get_log_time = sub {
    return $mocked_log_time;
};

sub setup {
    $pve_replication_state_module->mock(job_logfile_name => $mocked_job_logfile_name);
    $pve_replication_module->mock(get_log_time => $mocked_get_log_time);

    $pve_storage_module->mock(config => sub { return $mocked_storage_config; });
    $pve_storage_module->mock(volume_snapshot_list => $mocked_volume_snapshot_list);
    $pve_storage_module->mock(volume_snapshot => $mocked_volume_snapshot);
    $pve_storage_module->mock(volume_snapshot_delete => $mocked_volume_snapshot_delete);

    $pve_replication_config_module->mock(new => $mocked_replication_config_new);
    $pve_qemuserver_module->mock(check_running => sub { return 0; });
    $pve_qemuconfig_module->mock(load_config => $mocked_qemu_load_conf);

    $pve_lxc_config_module->mock(load_config => $mocked_lxc_load_conf);


    $pve_cluster_module->mock(
	get_ssh_info => $mocked_get_ssh_info,
	ssh_info_to_command => $mocked_ssh_info_to_command,
	get_vmlist => sub { return $mocked_vmlist->(); },
	get_members => $mocked_get_members);
    $pve_inotify_module->mock('nodename' => sub { return $mocked_nodename; });
};

# code to generate/conpare test logs

my $logname;
my $logfh;

sub openlog {
    my ($filename) = @_;

    if (!$filename) {
	# compute from $0
	$filename = basename($0);
	if ($filename =~ m/^(\S+)\.pl$/) {
	    $filename = "$1.log";
	} else {
	    die "unable to compute log name for $0";
	}
    }

    die "log already open" if defined($logname);

    open (my $fh, ">", "$filename.tmp") ||
	die "unable to open log  - $!";

    $logname = $filename;
    $logfh = $fh;
}

sub commit_log {

    close($logfh);

    if (-f $logname) {
	my $diff = `diff -u '$logname' '$logname.tmp'`;
	if ($diff) {
	    warn "got unexpeted output\n";
	    print "# diff -u '$logname' '$logname.tmp'\n";
	    print $diff;
	    exit(-1);
	}
    } else {
	rename("$logname.tmp", $logname) || die "rename log failed - $!";
    }
}

my $status;

# helper to track job status
sub track_jobs {
    my ($ctime) = @_;

    $mocked_log_time = $ctime;

    my $logmsg = sub {
	my ($msg) = @_;

	print "$msg\n";
	print $logfh "$msg\n";
    };

    if (!$status) {
	$status = PVE::ReplicationState::job_status();
	foreach my $jobid (sort keys %$status) {
	    my $jobcfg = $status->{$jobid};
	    $logmsg->("$ctime $jobid: new job next_sync => $jobcfg->{next_sync}");
	}
    }

    PVE::API2::Replication::run_jobs($ctime, $logmsg, 1);

    my $new = PVE::ReplicationState::job_status();

    # detect removed jobs
    foreach my $jobid (sort keys %$status) {
	if (!$new->{$jobid}) {
	    $logmsg->("$ctime $jobid: vanished job");
	}
    }

    foreach my $jobid (sort keys %$new) {
	my $jobcfg = $new->{$jobid};
	my $oldcfg = $status->{$jobid};
	if (!$oldcfg) {
	    $logmsg->("$ctime $jobid: new job next_sync => $jobcfg->{next_sync}");
	    next; # no old state to compare
	} else {
	    foreach my $k (qw(target guest vmtype next_sync)) {
		my $changes = '';
		if ($oldcfg->{$k} ne $jobcfg->{$k}) {
		    $changes .= ', ' if $changes;
		    $changes .= "$k => $jobcfg->{$k}";
		}
		$logmsg->("$ctime $jobid: changed config $changes") if $changes;
	    }
	}

	my $oldstate = $oldcfg->{state};

	my $state = $jobcfg->{state};

	my $changes = '';
	foreach my $k (qw(last_node last_try last_sync fail_count error)) {
	    if (($oldstate->{$k} // '') ne ($state->{$k} // '')) {
		my $value = $state->{$k} // '';
		chomp $value;
		$changes .= ', ' if $changes;
		$changes .= "$k => $value";
	    }
	}
	$logmsg->("$ctime $jobid: changed state $changes") if $changes;

	my $old_storeid_list = $oldstate->{storeid_list};
	my $storeid_list = $state->{storeid_list};

	my $storeid_list_changes = 0;
	foreach my $storeid (@$storeid_list) {
	    next if grep { $_ eq $storeid } @$old_storeid_list;
	    $storeid_list_changes = 1;
	}

	foreach my $storeid (@$old_storeid_list) {
	    next if grep { $_ eq $storeid } @$storeid_list;
	    $storeid_list_changes = 1;
	}

	$logmsg->("$ctime $jobid: changed storeid list " . join(',', @$storeid_list))
	    if $storeid_list_changes;
    }
    $status = $new;
}


1;
Commit	Line	Data
d0920c29 DM	1	package ReplicationTestEnv;
	2
	3	use strict;
	4	use warnings;
	5	use JSON;
c5014e65 DM	6	use Clone 'clone';
c5014e65 DM	7	use File::Basename;
d0920c29 DM	8
	9	use lib ('.', '../..');
	10
	11	use Data::Dumper;
	12
	13	use PVE::INotify;
	14	use PVE::Cluster;
	15	use PVE::Storage;
d255af01 DM	16	use PVE::ReplicationConfig;
d255af01 DM	17	use PVE::ReplicationState;
810c6776	18	use PVE::API2::Replication;
d0920c29 DM	19	use PVE::Replication;
	20	use PVE::QemuConfig;
	21	use PVE::LXC::Config;
	22
810c6776	23
d0920c29 DM	24	use Test::MockModule;
	25
	26	our $mocked_nodename = 'node1';
	27
	28	our $mocked_replication_jobs = {};
	29
d092dc4f DM	30	my $pve_replication_config_module = Test::MockModule->new('PVE::ReplicationConfig');
d092dc4f DM	31	my $pve_replication_state_module = Test::MockModule->new('PVE::ReplicationState');
d0920c29 DM	32
	33	our $mocked_vm_configs = {};
	34
	35	our $mocked_ct_configs = {};
	36
12c206a5 WB	37	my $mocked_get_members = sub {
	38	return {
	39	node1 => { online => 1 },
	40	node2 => { online => 1 },
	41	node3 => { online => 1 },
	42	};
	43	};
	44
d0920c29 DM	45	my $mocked_vmlist = sub {
	46	my $res = {};
	47
	48	foreach my $id (keys %$mocked_ct_configs) {
	49	my $d = $mocked_ct_configs->{$id};
	50	$res->{$id} = { 'type' => 'lxc', 'node' => $d->{node}, 'version' => 1 };
	51	}
	52	foreach my $id (keys %$mocked_vm_configs) {
	53	my $d = $mocked_vm_configs->{$id};
	54	$res->{$id} = { 'type' => 'qemu', 'node' => $d->{node}, 'version' => 1 };
	55	}
	56
	57	return { 'ids' => $res };
	58	};
	59
331025d9 DM	60	my $mocked_get_ssh_info = sub {
	61	my ($node, $network_cidr) = @_;
	62
	63	return { node => $node };
	64	};
	65
	66	my $mocked_ssh_info_to_command = sub {
	67	my ($info, @extra_options) = @_;
	68
	69	return ['fake_ssh', $info->{name}, @extra_options];
	70	};
d0920c29 DM	71
	72	my $statefile = ".mocked_repl_state";
	73
	74	unlink $statefile;
d255af01 DM	75	$PVE::ReplicationState::state_path = $statefile;
d255af01 DM	76	$PVE::ReplicationState::state_lock = ".mocked_repl_state_lock";
5b358450	77	$PVE::API2::Replication::pvesr_lock_path = ".mocked_pvesr_lock";
72741c0b WB	78	$PVE::GuestHelpers::lockdir = ".mocked_pve-manager_lock";
	79
	80	if (!mkdir($PVE::GuestHelpers::lockdir) && !$!{EEXIST}) {
	81	# If we cannot create the guest helper lockdir we'll loop endlessly, so die
	82	# if it fails.
	83	die "mkdir($PVE::GuestHelpers::lockdir): $!\n";
	84	}
d0920c29	85
d0920c29 DM	86	my $pve_cluster_module = Test::MockModule->new('PVE::Cluster');
	87
	88	my $pve_inotify_module = Test::MockModule->new('PVE::INotify');
	89
	90	my $mocked_qemu_load_conf = sub {
	91	my ($class, $vmid, $node) = @_;
	92
	93	$node = $mocked_nodename if !$node;
	94
	95	my $conf = $mocked_vm_configs->{$vmid};
	96
	97	die "no such vm '$vmid'" if !defined($conf);
	98	die "vm '$vmid' on wrong node" if $conf->{node} ne $node;
	99
	100	return $conf;
	101	};
	102
	103	my $pve_qemuserver_module = Test::MockModule->new('PVE::QemuServer');
	104
	105	my $pve_qemuconfig_module = Test::MockModule->new('PVE::QemuConfig');
	106
	107	my $mocked_lxc_load_conf = sub {
	108	my ($class, $vmid, $node) = @_;
	109
	110	$node = $mocked_nodename if !$node;
	111
	112	my $conf = $mocked_ct_configs->{$vmid};
	113
	114	die "no such ct '$vmid'" if !defined($conf);
	115	die "ct '$vmid' on wrong node" if $conf->{node} ne $node;
	116
	117	return $conf;
	118	};
	119
	120	my $pve_lxc_config_module = Test::MockModule->new('PVE::LXC::Config');
	121
d092dc4f	122	my $mocked_replication_config_new = sub {
d0920c29	123
c5014e65 DM	124	my $res = clone($mocked_replication_jobs);
c5014e65 DM	125
d0920c29 DM	126	return bless { ids => $res }, 'PVE::ReplicationConfig';
	127	};
	128
	129	my $mocked_storage_config = {
	130	ids => {
	131	local => {
	132	type => 'dir',
	133	shared => 0,
	134	content => {
	135	'iso' => 1,
	136	'backup' => 1,
	137	},
	138	path => "/var/lib/vz",
	139	},
	140	'local-zfs' => {
	141	type => 'zfspool',
	142	pool => 'nonexistent-testpool',
	143	shared => 0,
	144	content => {
	145	'images' => 1,
	146	'rootdir' => 1
	147	},
	148	},
	149	},
	150	};
	151
	152	my $pve_storage_module = Test::MockModule->new('PVE::Storage');
c5014e65	153
4550bb78 DM	154	my $mocked_storage_content = {};
	155
	156	sub register_mocked_volid {
	157	my ($volid, $snapname) = @_;
	158
	159	my ($storeid, $volname) = PVE::Storage::parse_volume_id($volid);
331025d9	160	my $scfg = $mocked_storage_config->{ids}->{$storeid} \|\|
4550bb78 DM	161	die "no such storage '$storeid'\n";
	162
	163	my $d = $mocked_storage_content->{$storeid}->{$volname} //= {};
	164
	165	$d->{$snapname} = 1 if $snapname;
	166	}
	167
	168	my $mocked_volume_snapshot_list = sub {
	169	my ($cfg, $volid, $prefix) = @_;
	170
	171	my ($storeid, $volname) = PVE::Storage::parse_volume_id($volid);
	172	my $snaps = [];
	173
	174	if (my $d = $mocked_storage_content->{$storeid}->{$volname}) {
	175	$snaps = [keys %$d];
	176	}
	177
	178	return $snaps;
	179	};
	180
	181	my $mocked_volume_snapshot = sub {
	182	my ($cfg, $volid, $snap) = @_;
	183
	184	my ($storeid, $volname) = PVE::Storage::parse_volume_id($volid);
	185
	186	my $d = $mocked_storage_content->{$storeid}->{$volname};
	187	die "no such volid '$volid'\n" if !$d;
	188	$d->{$snap} = 1;
	189	};
	190
	191	my $mocked_volume_snapshot_delete = sub {
	192	my ($cfg, $volid, $snap, $running) = @_;
	193
	194	my ($storeid, $volname) = PVE::Storage::parse_volume_id($volid);
	195	my $d = $mocked_storage_content->{$storeid}->{$volname};
	196	die "no such volid '$volid'\n" if !$d;
	197	delete $d->{$snap} \|\| die "no such snapshot '$snap' on '$volid'\n";
	198	};
	199
f842e812 DM	200	my $pve_replication_module = Test::MockModule->new('PVE::Replication');
	201
	202	my $mocked_job_logfile_name = sub {
	203	my ($jobid) = @_;
	204
	205	return ".mocked_replication_log_$jobid";
	206	};
	207
	208	my $mocked_log_time = 0;
	209
	210	my $mocked_get_log_time = sub {
	211	return $mocked_log_time;
	212	};
	213
d0920c29	214	sub setup {
d092dc4f	215	$pve_replication_state_module->mock(job_logfile_name => $mocked_job_logfile_name);
f842e812 DM	216	$pve_replication_module->mock(get_log_time => $mocked_get_log_time);
f842e812 DM	217
d0920c29	218	$pve_storage_module->mock(config => sub { return $mocked_storage_config; });
4550bb78 DM	219	$pve_storage_module->mock(volume_snapshot_list => $mocked_volume_snapshot_list);
	220	$pve_storage_module->mock(volume_snapshot => $mocked_volume_snapshot);
	221	$pve_storage_module->mock(volume_snapshot_delete => $mocked_volume_snapshot_delete);
d0920c29	222
d092dc4f	223	$pve_replication_config_module->mock(new => $mocked_replication_config_new);
d0920c29 DM	224	$pve_qemuserver_module->mock(check_running => sub { return 0; });
	225	$pve_qemuconfig_module->mock(load_config => $mocked_qemu_load_conf);
	226
	227	$pve_lxc_config_module->mock(load_config => $mocked_lxc_load_conf);
	228
	229
331025d9 DM	230	$pve_cluster_module->mock(
	231	get_ssh_info => $mocked_get_ssh_info,
	232	ssh_info_to_command => $mocked_ssh_info_to_command,
12c206a5 WB	233	get_vmlist => sub { return $mocked_vmlist->(); },
12c206a5 WB	234	get_members => $mocked_get_members);
d0920c29 DM	235	$pve_inotify_module->mock('nodename' => sub { return $mocked_nodename; });
	236	};
	237
c5014e65 DM	238	# code to generate/conpare test logs
	239
	240	my $logname;
	241	my $logfh;
	242
	243	sub openlog {
	244	my ($filename) = @_;
	245
	246	if (!$filename) {
	247	# compute from $0
	248	$filename = basename($0);
	249	if ($filename =~ m/^(\S+)\.pl$/) {
	250	$filename = "$1.log";
	251	} else {
	252	die "unable to compute log name for $0";
	253	}
	254	}
	255
	256	die "log already open" if defined($logname);
	257
	258	open (my $fh, ">", "$filename.tmp") \|\|
	259	die "unable to open log - $!";
	260
	261	$logname = $filename;
	262	$logfh = $fh;
	263	}
	264
c5014e65 DM	265	sub commit_log {
	266
	267	close($logfh);
	268
	269	if (-f $logname) {
	270	my $diff = `diff -u '$logname' '$logname.tmp'`;
	271	if ($diff) {
	272	warn "got unexpeted output\n";
	273	print "# diff -u '$logname' '$logname.tmp'\n";
	274	print $diff;
	275	exit(-1);
	276	}
	277	} else {
	278	rename("$logname.tmp", $logname) \|\| die "rename log failed - $!";
	279	}
	280	}
	281
	282	my $status;
	283
	284	# helper to track job status
	285	sub track_jobs {
	286	my ($ctime) = @_;
	287
f842e812 DM	288	$mocked_log_time = $ctime;
f842e812 DM	289
c364b61f DM	290	my $logmsg = sub {
	291	my ($msg) = @_;
	292
f842e812 DM	293	print "$msg\n";
f842e812 DM	294	print $logfh "$msg\n";
c364b61f DM	295	};
c364b61f DM	296
c5014e65	297	if (!$status) {
d092dc4f	298	$status = PVE::ReplicationState::job_status();
c5014e65 DM	299	foreach my $jobid (sort keys %$status) {
c5014e65 DM	300	my $jobcfg = $status->{$jobid};
f842e812	301	$logmsg->("$ctime $jobid: new job next_sync => $jobcfg->{next_sync}");
c5014e65 DM	302	}
	303	}
	304
2aa02957	305	PVE::API2::Replication::run_jobs($ctime, $logmsg, 1);
c5014e65	306
d092dc4f	307	my $new = PVE::ReplicationState::job_status();
c5014e65 DM	308
	309	# detect removed jobs
	310	foreach my $jobid (sort keys %$status) {
	311	if (!$new->{$jobid}) {
f842e812	312	$logmsg->("$ctime $jobid: vanished job");
c5014e65 DM	313	}
	314	}
	315
	316	foreach my $jobid (sort keys %$new) {
	317	my $jobcfg = $new->{$jobid};
	318	my $oldcfg = $status->{$jobid};
	319	if (!$oldcfg) {
f842e812	320	$logmsg->("$ctime $jobid: new job next_sync => $jobcfg->{next_sync}");
c5014e65 DM	321	next; # no old state to compare
	322	} else {
	323	foreach my $k (qw(target guest vmtype next_sync)) {
	324	my $changes = '';
	325	if ($oldcfg->{$k} ne $jobcfg->{$k}) {
	326	$changes .= ', ' if $changes;
	327	$changes .= "$k => $jobcfg->{$k}";
	328	}
f842e812	329	$logmsg->("$ctime $jobid: changed config $changes") if $changes;
c5014e65 DM	330	}
	331	}
	332
	333	my $oldstate = $oldcfg->{state};
356fbf79	334
c5014e65 DM	335	my $state = $jobcfg->{state};
	336
	337	my $changes = '';
e137f69f	338	foreach my $k (qw(last_node last_try last_sync fail_count error)) {
c5014e65	339	if (($oldstate->{$k} // '') ne ($state->{$k} // '')) {
39c41c9d	340	my $value = $state->{$k} // '';
c5014e65 DM	341	chomp $value;
	342	$changes .= ', ' if $changes;
	343	$changes .= "$k => $value";
	344	}
	345	}
f842e812	346	$logmsg->("$ctime $jobid: changed state $changes") if $changes;
c5014e65	347
356fbf79 DM	348	my $old_storeid_list = $oldstate->{storeid_list};
	349	my $storeid_list = $state->{storeid_list};
	350
	351	my $storeid_list_changes = 0;
	352	foreach my $storeid (@$storeid_list) {
	353	next if grep { $_ eq $storeid } @$old_storeid_list;
	354	$storeid_list_changes = 1;
	355	}
	356
	357	foreach my $storeid (@$old_storeid_list) {
	358	next if grep { $_ eq $storeid } @$storeid_list;
	359	$storeid_list_changes = 1;
	360	}
	361
f842e812	362	$logmsg->("$ctime $jobid: changed storeid list " . join(',', @$storeid_list))
356fbf79	363	if $storeid_list_changes;
c5014e65 DM	364	}
	365	$status = $new;
	366	}
d0920c29 DM	367
	368
	369	1;