[pve-manager.git] / www / manager6 / tree / SnapshotTree.js

Ext.define('PVE.guest.SnapshotTree', {
    extend: 'Ext.tree.Panel',
    xtype: 'pveGuestSnapshotTree',

    stateful: true,
    stateId: 'grid-snapshots',

    viewModel: {
	data: {
	    // should be 'qemu' or 'lxc'
	    type: undefined,
	    nodename: undefined,
	    vmid: undefined,
	    snapshotAllowed: false,
	    rollbackAllowed: false,
	    snapshotFeature: false,
	    running: false,
	    selected: '',
	    load_delay: 3000,
	},
	formulas: {
	    canSnapshot: (get) => get('snapshotAllowed') && get('snapshotFeature'),
	    canRollback: (get) => get('rollbackAllowed') && get('isSnapshot'),
	    canRemove: (get) => get('snapshotAllowed') && get('isSnapshot'),
	    isSnapshot: (get) => get('selected') && get('selected') !== 'current',
	    buttonText: (get) => get('snapshotAllowed') ? gettext('Edit') : gettext('View'),
	    showMemory: (get) => get('type') === 'qemu',
	},
    },

    controller: {
	xclass: 'Ext.app.ViewController',

	newSnapshot: function() {
	    this.run_editor(false);
	},

	editSnapshot: function() {
	    this.run_editor(true);
	},

	run_editor: function(edit) {
	    let me = this;
	    let vm = me.getViewModel();
	    let snapname;
	    if (edit) {
		snapname = vm.get('selected');
		if (!snapname || snapname === 'current') { return; }
	    }
	    let win = Ext.create('PVE.window.Snapshot', {
		nodename: vm.get('nodename'),
		vmid: vm.get('vmid'),
		viewonly: !vm.get('snapshotAllowed'),
		type: vm.get('type'),
		isCreate: !edit,
		submitText: !edit ? gettext('Take Snapshot') : undefined,
		snapname: snapname,
		running: vm.get('running'),
	    });
	    win.show();
	    me.mon(win, 'destroy', me.reload, me);
	},

	snapshotAction: function(action, method) {
	    let me = this;
	    let view = me.getView();
	    let vm = me.getViewModel();
	    let snapname = vm.get('selected');
	    if (!snapname) { return; }

	    let nodename = vm.get('nodename');
	    let type = vm.get('type');
	    let vmid = vm.get('vmid');

	    Proxmox.Utils.API2Request({
		url: `/nodes/${nodename}/${type}/${vmid}/snapshot/${snapname}/${action}`,
		method: method,
		waitMsgTarget: view,
		callback: function() {
		    me.reload();
		},
		failure: function (response, opts) {
		    Ext.Msg.alert(gettext('Error'), response.htmlStatus);
		},
		success: function(response, options) {
		    var upid = response.result.data;
		    var win = Ext.create('Proxmox.window.TaskProgress', { upid: upid });
		    win.show();
		}
	    });
	},

	rollback: function() {
	    this.snapshotAction('rollback', 'POST');
	},
	remove: function() {
	    this.snapshotAction('', 'DELETE');
	},
	cancel: function() {
	    this.load_task.cancel();
	},

	reload: function() {
	    let me = this;
	    let view = me.getView();
	    let vm = me.getViewModel();
	    let nodename = vm.get('nodename');
	    let vmid = vm.get('vmid');
	    let type = vm.get('type');
	    let load_delay = vm.get('load_delay');

	    Proxmox.Utils.API2Request({
		url: `/nodes/${nodename}/${type}/${vmid}/snapshot`,
		method: 'GET',
		failure: function(response, opts) {
		    if (me.destroyed) return;
		    Proxmox.Utils.setErrorMask(view, response.htmlStatus);
		    me.load_task.delay(load_delay);
		},
		success: function(response, opts) {
		    if (me.destroyed) {
			// this is in a delayed task, avoid dragons if view has
			// been destroyed already and go home.
			return;
		    }
		    Proxmox.Utils.setErrorMask(view, false);
		    var digest = 'invalid';
		    var idhash = {};
		    var root = { name: '__root', expanded: true, children: [] };
		    Ext.Array.each(response.result.data, function(item) {
			item.leaf = true;
			item.children = [];
			if (item.name === 'current') {
			    vm.set('running', !!item.running);
			    digest = item.digest + item.running;
			    item.iconCls = PVE.Utils.get_object_icon_class(vm.get('type'), item);
			} else {
			    item.iconCls = 'fa fa-fw fa-history x-fa-tree';
			}
			idhash[item.name] = item;
		    });

		    if (digest !== me.old_digest) {
			me.old_digest = digest;

			Ext.Array.each(response.result.data, function(item) {
			    if (item.parent && idhash[item.parent]) {
				var parent_item = idhash[item.parent];
				parent_item.children.push(item);
				parent_item.leaf = false;
				parent_item.expanded = true;
				parent_item.expandable = false;
			    } else {
				root.children.push(item);
			    }
			});

			me.getView().setRootNode(root);
		    }

		    me.load_task.delay(load_delay);
		}
	    });

	    // if we do not have the permissions, we don't have to check
	    // if we can create a snapshot, since the butten stays disabled
	    if (!vm.get('snapshotAllowed')) {
		return;
	    }

	    Proxmox.Utils.API2Request({
		url: `/nodes/${nodename}/${type}/${vmid}/feature`,
		params: { feature: 'snapshot' },
		method: 'GET',
		success: function(response, options) {
		    if (me.destroyed) {
			// this is in a delayed task, the current view could been
			// destroyed already; then we mustn't do viemodel set
			return;
		    }
		    let res = response.result.data;
		    vm.set('snapshotFeature', !!res.hasFeature);
		}
	    });
	},

	select: function(grid, val) {
	    let vm = this.getViewModel();
	    if (val.length < 1) {
		vm.set('selected', '');
		return;
	    }
	    vm.set('selected', val[0].data.name);
	},

	init: function(view) {
	    let me = this;
	    let vm = me.getViewModel();
	    me.load_task = new Ext.util.DelayedTask(me.reload, me);

	    if (!view.type) {
		throw 'guest type not set';
	    }
	    vm.set('type', view.type);

	    if (!view.pveSelNode.data.node) {
		throw "no node name specified";
	    }
	    vm.set('nodename', view.pveSelNode.data.node);

	    if (!view.pveSelNode.data.vmid) {
		throw "no VM ID specified";
	    }
	    vm.set('vmid', view.pveSelNode.data.vmid);

	    let caps = Ext.state.Manager.get('GuiCap');
	    vm.set('snapshotAllowed', !!caps.vms['VM.Snapshot']);
	    vm.set('rollbackAllowed', !!caps.vms['VM.Snapshot.Rollback']);

	    view.getStore().sorters.add({
		property: 'order',
		direction: 'ASC',
	    });

	    me.reload();
	},
    },

    listeners: {
	selectionchange: 'select',
	itemdblclick: 'editSnapshot',
	destroy: 'cancel',
    },

    layout: 'fit',
    rootVisible: false,
    animate: false,
    sortableColumns: false,

    tbar: [
	{
	    xtype: 'proxmoxButton',
	    text: gettext('Take Snapshot'),
	    disabled: true,
	    bind: {
		disabled: "{!canSnapshot}",
	    },
	    handler: 'newSnapshot',
	},
	'-',
	{
	    xtype: 'proxmoxButton',
	    text: gettext('Rollback'),
	    disabled: true,
	    bind: {
		disabled: '{!canRollback}',
	    },
	    confirmMsg: function() {
		let view = this.up('treepanel');
		let rec = view.getSelection()[0];
		let vmid = view.getViewModel().get('vmid');
		return Proxmox.Utils.format_task_description('qmrollback', vmid) +
		    " '" +  rec.data.name + "'";
	    },
	    handler: 'rollback',
	},
	{
	    xtype: 'proxmoxButton',
	    text: gettext('Edit'),
	    bind: {
		text: '{buttonText}',
		disabled: '{!isSnapshot}',
	    },
	    disabled: true,
	    edit: true,
	    handler: 'editSnapshot',
	},
	{
	    xtype: 'proxmoxButton',
	    text: gettext('Remove'),
	    disabled: true,
	    dangerous: true,
	    bind: {
		disabled: '{!canRemove}',
	    },
	    confirmMsg: function() {
		let view = this.up('treepanel');
		let rec = view.getSelection()[0];
		return Ext.String.format(
		    gettext('Are you sure you want to remove entry {0}'),
		    `'${rec.data.name}'`
		);
	    },
	    handler: 'remove',
	},
	{
	    xtype: 'label',
	    text: gettext("The current guest configuration does not support taking new snapshots"),
	    hidden: true,
	    bind: {
		hidden: "{canSnapshot}",
	    },
	},
    ],

    columnLines: true,

    fields: [
	'name', 'description', 'snapstate', 'vmstate', 'running',
	{ name: 'snaptime', type: 'date', dateFormat: 'timestamp' },
	{
	    name: 'order',
	    calculate: function(data) {
		return data.snaptime || (data.name === 'current' ? 'ZZZ' : data.snapstate);
	    }
	}
    ],

    columns: [
	{
	    xtype: 'treecolumn',
	    text: gettext('Name'),
	    dataIndex: 'name',
	    width: 200,
	    renderer: function(value, metaData, record) {
		if (value === 'current') {
		    return gettext('NOW');
		} else {
		    return value;
		}
	    }
	},
	{
	    text: gettext('RAM'),
	    hidden: true,
	    bind: {
		hidden: '{!showMemory}',
	    },
	    align: 'center',
	    resizable: false,
	    dataIndex: 'vmstate',
	    width: 50,
	    renderer: function(value, metaData, record) {
		if (record.data.name !== 'current') {
		    return Proxmox.Utils.format_boolean(value);
		}
	    }
	},
	{
	    text: gettext('Date') + "/" + gettext("Status"),
	    dataIndex: 'snaptime',
	    width: 150,
	    renderer: function(value, metaData, record) {
		if (record.data.snapstate) {
		    return record.data.snapstate;
		}
		if (value) {
		    return Ext.Date.format(value,'Y-m-d H:i:s');
		}
	    }
	},
	{
	    text: gettext('Description'),
	    dataIndex: 'description',
	    flex: 1,
	    renderer: function(value, metaData, record) {
		if (record.data.name === 'current') {
		    return gettext("You are here!");
		} else {
		    return Ext.String.htmlEncode(value);
		}
	    }
	}
    ],

});
Commit	Line	Data
5b1b9360 DC	1	Ext.define('PVE.guest.SnapshotTree', {
	2	extend: 'Ext.tree.Panel',
	3	xtype: 'pveGuestSnapshotTree',
	4
	5	stateful: true,
	6	stateId: 'grid-snapshots',
	7
	8	viewModel: {
	9	data: {
	10	// should be 'qemu' or 'lxc'
	11	type: undefined,
	12	nodename: undefined,
	13	vmid: undefined,
	14	snapshotAllowed: false,
	15	rollbackAllowed: false,
	16	snapshotFeature: false,
7fb02366	17	running: false,
5b1b9360 DC	18	selected: '',
	19	load_delay: 3000,
	20	},
	21	formulas: {
b9c780c5 TL	22	canSnapshot: (get) => get('snapshotAllowed') && get('snapshotFeature'),
	23	canRollback: (get) => get('rollbackAllowed') && get('isSnapshot'),
	24	canRemove: (get) => get('snapshotAllowed') && get('isSnapshot'),
	25	isSnapshot: (get) => get('selected') && get('selected') !== 'current',
c16c1302	26	buttonText: (get) => get('snapshotAllowed') ? gettext('Edit') : gettext('View'),
b9c780c5	27	showMemory: (get) => get('type') === 'qemu',
5b1b9360 DC	28	},
	29	},
	30
	31	controller: {
	32	xclass: 'Ext.app.ViewController',
	33
	34	newSnapshot: function() {
	35	this.run_editor(false);
	36	},
	37
	38	editSnapshot: function() {
	39	this.run_editor(true);
	40	},
	41
	42	run_editor: function(edit) {
	43	let me = this;
	44	let vm = me.getViewModel();
	45	let snapname;
	46	if (edit) {
	47	snapname = vm.get('selected');
	48	if (!snapname \|\| snapname === 'current') { return; }
	49	}
	50	let win = Ext.create('PVE.window.Snapshot', {
	51	nodename: vm.get('nodename'),
	52	vmid: vm.get('vmid'),
	53	viewonly: !vm.get('snapshotAllowed'),
	54	type: vm.get('type'),
	55	isCreate: !edit,
	56	submitText: !edit ? gettext('Take Snapshot') : undefined,
	57	snapname: snapname,
7fb02366	58	running: vm.get('running'),
5b1b9360 DC	59	});
	60	win.show();
	61	me.mon(win, 'destroy', me.reload, me);
	62	},
	63
	64	snapshotAction: function(action, method) {
	65	let me = this;
	66	let view = me.getView();
	67	let vm = me.getViewModel();
	68	let snapname = vm.get('selected');
	69	if (!snapname) { return; }
	70
	71	let nodename = vm.get('nodename');
	72	let type = vm.get('type');
	73	let vmid = vm.get('vmid');
	74
	75	Proxmox.Utils.API2Request({
	76	url: `/nodes/${nodename}/${type}/${vmid}/snapshot/${snapname}/${action}`,
	77	method: method,
	78	waitMsgTarget: view,
	79	callback: function() {
	80	me.reload();
	81	},
	82	failure: function (response, opts) {
	83	Ext.Msg.alert(gettext('Error'), response.htmlStatus);
	84	},
	85	success: function(response, options) {
	86	var upid = response.result.data;
	87	var win = Ext.create('Proxmox.window.TaskProgress', { upid: upid });
	88	win.show();
	89	}
	90	});
	91	},
	92
9a6b894f TL	93	rollback: function() {
	94	this.snapshotAction('rollback', 'POST');
	95	},
	96	remove: function() {
	97	this.snapshotAction('', 'DELETE');
	98	},
5b1b9360 DC	99	cancel: function() {
	100	this.load_task.cancel();
	101	},
	102
	103	reload: function() {
	104	let me = this;
	105	let view = me.getView();
	106	let vm = me.getViewModel();
	107	let nodename = vm.get('nodename');
	108	let vmid = vm.get('vmid');
	109	let type = vm.get('type');
	110	let load_delay = vm.get('load_delay');
	111
	112	Proxmox.Utils.API2Request({
	113	url: `/nodes/${nodename}/${type}/${vmid}/snapshot`,
	114	method: 'GET',
	115	failure: function(response, opts) {
87ae19d1	116	if (me.destroyed) return;
5b1b9360 DC	117	Proxmox.Utils.setErrorMask(view, response.htmlStatus);
	118	me.load_task.delay(load_delay);
	119	},
	120	success: function(response, opts) {
87ae19d1 TL	121	if (me.destroyed) {
	122	// this is in a delayed task, avoid dragons if view has
	123	// been destroyed already and go home.
	124	return;
	125	}
5b1b9360 DC	126	Proxmox.Utils.setErrorMask(view, false);
	127	var digest = 'invalid';
	128	var idhash = {};
	129	var root = { name: '__root', expanded: true, children: [] };
	130	Ext.Array.each(response.result.data, function(item) {
	131	item.leaf = true;
	132	item.children = [];
	133	if (item.name === 'current') {
7fb02366	134	vm.set('running', !!item.running);
5b1b9360 DC	135	digest = item.digest + item.running;
	136	item.iconCls = PVE.Utils.get_object_icon_class(vm.get('type'), item);
	137	} else {
	138	item.iconCls = 'fa fa-fw fa-history x-fa-tree';
	139	}
	140	idhash[item.name] = item;
	141	});
	142
	143	if (digest !== me.old_digest) {
	144	me.old_digest = digest;
	145
	146	Ext.Array.each(response.result.data, function(item) {
	147	if (item.parent && idhash[item.parent]) {
	148	var parent_item = idhash[item.parent];
	149	parent_item.children.push(item);
	150	parent_item.leaf = false;
	151	parent_item.expanded = true;
	152	parent_item.expandable = false;
	153	} else {
	154	root.children.push(item);
	155	}
	156	});
	157
	158	me.getView().setRootNode(root);
	159	}
	160
	161	me.load_task.delay(load_delay);
	162	}
	163	});
	164
	165	// if we do not have the permissions, we don't have to check
	166	// if we can create a snapshot, since the butten stays disabled
	167	if (!vm.get('snapshotAllowed')) {
	168	return;
	169	}
	170
	171	Proxmox.Utils.API2Request({
	172	url: `/nodes/${nodename}/${type}/${vmid}/feature`,
	173	params: { feature: 'snapshot' },
	174	method: 'GET',
	175	success: function(response, options) {
9cc4958f TL	176	if (me.destroyed) {
	177	// this is in a delayed task, the current view could been
	178	// destroyed already; then we mustn't do viemodel set
	179	return;
	180	}
9a6b894f TL	181	let res = response.result.data;
	182	vm.set('snapshotFeature', !!res.hasFeature);
	183	}
5b1b9360 DC	184	});
	185	},
	186
	187	select: function(grid, val) {
	188	let vm = this.getViewModel();
	189	if (val.length < 1) {
	190	vm.set('selected', '');
	191	return;
	192	}
	193	vm.set('selected', val[0].data.name);
	194	},
	195
	196	init: function(view) {
	197	let me = this;
	198	let vm = me.getViewModel();
	199	me.load_task = new Ext.util.DelayedTask(me.reload, me);
	200
	201	if (!view.type) {
	202	throw 'guest type not set';
	203	}
	204	vm.set('type', view.type);
	205
	206	if (!view.pveSelNode.data.node) {
	207	throw "no node name specified";
	208	}
	209	vm.set('nodename', view.pveSelNode.data.node);
	210
	211	if (!view.pveSelNode.data.vmid) {
	212	throw "no VM ID specified";
	213	}
	214	vm.set('vmid', view.pveSelNode.data.vmid);
	215
	216	let caps = Ext.state.Manager.get('GuiCap');
	217	vm.set('snapshotAllowed', !!caps.vms['VM.Snapshot']);
	218	vm.set('rollbackAllowed', !!caps.vms['VM.Snapshot.Rollback']);
	219
	220	view.getStore().sorters.add({
	221	property: 'order',
	222	direction: 'ASC',
	223	});
	224
	225	me.reload();
	226	},
	227	},
	228
	229	listeners: {
	230	selectionchange: 'select',
	231	itemdblclick: 'editSnapshot',
	232	destroy: 'cancel',
	233	},
	234
	235	layout: 'fit',
	236	rootVisible: false,
	237	animate: false,
	238	sortableColumns: false,
	239
	240	tbar: [
	241	{
	242	xtype: 'proxmoxButton',
	243	text: gettext('Take Snapshot'),
	244	disabled: true,
	245	bind: {
	246	disabled: "{!canSnapshot}",
	247	},
248	handler: 'newSnapshot',
249	},
e1af1385	250	'-',
5b1b9360 DC	251	{
	252	xtype: 'proxmoxButton',
	253	text: gettext('Rollback'),
	254	disabled: true,
	255	bind: {
	256	disabled: '{!canRollback}',
	257	},
	258	confirmMsg: function() {
	259	let view = this.up('treepanel');
	260	let rec = view.getSelection()[0];
	261	let vmid = view.getViewModel().get('vmid');
	262	return Proxmox.Utils.format_task_description('qmrollback', vmid) +
	263	" '" + rec.data.name + "'";
	264	},
	265	handler: 'rollback',
	266	},
97f8afff MA	267	{
	268	xtype: 'proxmoxButton',
	269	text: gettext('Edit'),
	270	bind: {
	271	text: '{buttonText}',
	272	disabled: '{!isSnapshot}',
	273	},
	274	disabled: true,
	275	edit: true,
	276	handler: 'editSnapshot',
	277	},
5b1b9360 DC	278	{
	279	xtype: 'proxmoxButton',
	280	text: gettext('Remove'),
	281	disabled: true,
97f8afff	282	dangerous: true,
5b1b9360 DC	283	bind: {
	284	disabled: '{!canRemove}',
	285	},
	286	confirmMsg: function() {
	287	let view = this.up('treepanel');
	288	let rec = view.getSelection()[0];
	289	return Ext.String.format(
	290	gettext('Are you sure you want to remove entry {0}'),
	291	`'${rec.data.name}'`
	292	);
	293	},
	294	handler: 'remove',
	295	},
e1af1385 TL	296	{
	297	xtype: 'label',
	298	text: gettext("The current guest configuration does not support taking new snapshots"),
	299	hidden: true,
	300	bind: {
	301	hidden: "{canSnapshot}",
	302	},
	303	},
5b1b9360 DC	304	],
	305
	306	columnLines: true,
	307
	308	fields: [
	309	'name', 'description', 'snapstate', 'vmstate', 'running',
	310	{ name: 'snaptime', type: 'date', dateFormat: 'timestamp' },
	311	{
	312	name: 'order',
	313	calculate: function(data) {
	314	return data.snaptime \|\| (data.name === 'current' ? 'ZZZ' : data.snapstate);
	315	}
	316	}
	317	],
	318
	319	columns: [
	320	{
	321	xtype: 'treecolumn',
	322	text: gettext('Name'),
	323	dataIndex: 'name',
	324	width: 200,
	325	renderer: function(value, metaData, record) {
	326	if (value === 'current') {
	327	return gettext('NOW');
	328	} else {
	329	return value;
	330	}
	331	}
	332	},
	333	{
	334	text: gettext('RAM'),
	335	hidden: true,
	336	bind: {
	337	hidden: '{!showMemory}',
	338	},
	339	align: 'center',
	340	resizable: false,
	341	dataIndex: 'vmstate',
	342	width: 50,
	343	renderer: function(value, metaData, record) {
	344	if (record.data.name !== 'current') {
	345	return Proxmox.Utils.format_boolean(value);
	346	}
	347	}
	348	},
	349	{
	350	text: gettext('Date') + "/" + gettext("Status"),
	351	dataIndex: 'snaptime',
	352	width: 150,
	353	renderer: function(value, metaData, record) {
	354	if (record.data.snapstate) {
	355	return record.data.snapstate;
	356	}
	357	if (value) {
	358	return Ext.Date.format(value,'Y-m-d H:i:s');
	359	}
	360	}
	361	},
	362	{
	363	text: gettext('Description'),
	364	dataIndex: 'description',
	365	flex: 1,
	366	renderer: function(value, metaData, record) {
	367	if (record.data.name === 'current') {
368	return gettext("You are here!");
369	} else {
370	return Ext.String.htmlEncode(value);
371	}
372	}
373	}
374	],
375
376	});