1209 lines
30 KiB
JavaScript
1209 lines
30 KiB
JavaScript
Ext.define('pbs-data-store-snapshots', {
|
|
extend: 'Ext.data.Model',
|
|
fields: [
|
|
'backup-type',
|
|
'backup-id',
|
|
{
|
|
name: 'backup-time',
|
|
type: 'date',
|
|
dateFormat: 'timestamp',
|
|
},
|
|
'comment',
|
|
'files',
|
|
'owner',
|
|
'verification',
|
|
'fingerprint',
|
|
{ name: 'size', type: 'int', allowNull: true },
|
|
{ name: 'sortWeight', type: 'int', allowNull: true },
|
|
{ name: 'ty', type: 'string', allowNull: true },
|
|
{
|
|
name: 'crypt-mode',
|
|
type: 'boolean',
|
|
calculate: function(data) {
|
|
let crypt = {
|
|
none: 0,
|
|
mixed: 0,
|
|
'sign-only': 0,
|
|
encrypt: 0,
|
|
count: 0,
|
|
};
|
|
data.files.forEach(file => {
|
|
if (file.filename === 'index.json.blob') return; // is never encrypted
|
|
let mode = PBS.Utils.cryptmap.indexOf(file['crypt-mode']);
|
|
if (mode !== -1) {
|
|
crypt[file['crypt-mode']]++;
|
|
crypt.count++;
|
|
}
|
|
});
|
|
|
|
return PBS.Utils.calculateCryptMode(crypt);
|
|
},
|
|
},
|
|
{
|
|
name: 'matchesFilter',
|
|
type: 'boolean',
|
|
defaultValue: true,
|
|
},
|
|
],
|
|
});
|
|
|
|
Ext.define('PBS.DataStoreContent', {
|
|
extend: 'Ext.tree.Panel',
|
|
alias: 'widget.pbsDataStoreContent',
|
|
mixins: ['Proxmox.Mixin.CBind'],
|
|
|
|
rootVisible: false,
|
|
|
|
title: gettext('Content'),
|
|
|
|
controller: {
|
|
xclass: 'Ext.app.ViewController',
|
|
|
|
init: function(view) {
|
|
if (!view.datastore) {
|
|
throw "no datastore specified";
|
|
}
|
|
|
|
this.store = Ext.create('Ext.data.Store', {
|
|
model: 'pbs-data-store-snapshots',
|
|
groupField: 'backup-group',
|
|
});
|
|
this.store.on('load', this.onLoad, this);
|
|
|
|
view.getStore().setSorters([
|
|
'sortWeight',
|
|
'text',
|
|
'backup-time',
|
|
]);
|
|
Proxmox.Utils.monStoreErrors(view, this.store);
|
|
},
|
|
|
|
control: {
|
|
'#': { // view
|
|
rowdblclick: 'rowDoubleClicked',
|
|
},
|
|
'pbsNamespaceSelector': {
|
|
change: 'nsChange',
|
|
},
|
|
},
|
|
|
|
rowDoubleClicked: function(table, rec, el, rowId, ev) {
|
|
if (rec?.data?.ty === 'ns' && !rec.data.root) {
|
|
this.nsChange(null, rec.data.ns);
|
|
}
|
|
},
|
|
|
|
nsChange: function(field, value) {
|
|
let view = this.getView();
|
|
if (field === null) {
|
|
field = view.down('pbsNamespaceSelector');
|
|
field.setValue(value);
|
|
return;
|
|
}
|
|
view.namespace = value;
|
|
this.reload();
|
|
},
|
|
|
|
reload: function() {
|
|
let view = this.getView();
|
|
|
|
if (!view.store || !this.store) {
|
|
console.warn('cannot reload, no store(s)');
|
|
return;
|
|
}
|
|
|
|
let url = `/api2/json/admin/datastore/${view.datastore}/snapshots`;
|
|
if (view.namespace && view.namespace !== '') {
|
|
url += `?ns=${encodeURIComponent(view.namespace)}`;
|
|
}
|
|
this.store.setProxy({
|
|
type: 'proxmox',
|
|
timeout: 300*1000, // 5 minutes, we should make that api call faster
|
|
url: url,
|
|
});
|
|
|
|
this.store.load();
|
|
},
|
|
|
|
getRecordGroups: function(records) {
|
|
let groups = {};
|
|
|
|
for (const item of records) {
|
|
var btype = item.data["backup-type"];
|
|
let group = btype + "/" + item.data["backup-id"];
|
|
|
|
if (groups[group] !== undefined) {
|
|
continue;
|
|
}
|
|
|
|
var cls = PBS.Utils.get_type_icon_cls(btype);
|
|
if (cls === "") {
|
|
console.warn(`got unknown backup-type '${btype}'`);
|
|
continue; // FIXME: auto render? what do?
|
|
}
|
|
|
|
groups[group] = {
|
|
text: group,
|
|
leaf: false,
|
|
iconCls: "fa " + cls,
|
|
expanded: false,
|
|
backup_type: item.data["backup-type"],
|
|
backup_id: item.data["backup-id"],
|
|
children: [],
|
|
};
|
|
}
|
|
|
|
return groups;
|
|
},
|
|
|
|
updateGroupNotes: async function(view) {
|
|
try {
|
|
let url = `/api2/extjs/admin/datastore/${view.datastore}/groups`;
|
|
if (view.namespace && view.namespace !== '') {
|
|
url += `?ns=${encodeURIComponent(view.namespace)}`;
|
|
}
|
|
let { result: { data: groups } } = await Proxmox.Async.api2({ url });
|
|
let map = {};
|
|
for (const group of groups) {
|
|
map[`${group["backup-type"]}/${group["backup-id"]}`] = group.comment;
|
|
}
|
|
view.getRootNode().cascade(node => {
|
|
if (node.data.ty === 'group') {
|
|
let group = `${node.data.backup_type}/${node.data.backup_id}`;
|
|
node.set('comment', map[group], { dirty: false });
|
|
}
|
|
});
|
|
} catch (err) {
|
|
console.debug(err);
|
|
}
|
|
},
|
|
|
|
loadNamespaceFromSameLevel: async function() {
|
|
let view = this.getView();
|
|
try {
|
|
let url = `/api2/extjs/admin/datastore/${view.datastore}/namespace?max-depth=1`;
|
|
if (view.namespace && view.namespace !== '') {
|
|
url += `&parent=${encodeURIComponent(view.namespace)}`;
|
|
}
|
|
let { result: { data: ns } } = await Proxmox.Async.api2({ url });
|
|
return ns;
|
|
} catch (err) {
|
|
console.debug(err);
|
|
}
|
|
return [];
|
|
},
|
|
|
|
onLoad: async function(store, records, success, operation) {
|
|
let me = this;
|
|
let view = this.getView();
|
|
|
|
if (!success) {
|
|
Proxmox.Utils.setErrorMask(view, Proxmox.Utils.getResponseErrorMessage(operation.getError()));
|
|
return;
|
|
}
|
|
|
|
let namespaces = await me.loadNamespaceFromSameLevel();
|
|
|
|
let groups = this.getRecordGroups(records);
|
|
|
|
let selected;
|
|
let expanded = {};
|
|
|
|
view.getSelection().some(function(item) {
|
|
let id = item.data.text;
|
|
if (item.data.leaf) {
|
|
id = item.parentNode.data.text + id;
|
|
}
|
|
selected = id;
|
|
return true;
|
|
});
|
|
|
|
view.getRootNode().cascadeBy({
|
|
before: item => {
|
|
if (item.isExpanded() && !item.data.leaf) {
|
|
let id = item.data.text;
|
|
expanded[id] = true;
|
|
return true;
|
|
}
|
|
return false;
|
|
},
|
|
after: Ext.emptyFn,
|
|
});
|
|
|
|
for (const item of records) {
|
|
let group = item.data["backup-type"] + "/" + item.data["backup-id"];
|
|
let children = groups[group].children;
|
|
|
|
let data = item.data;
|
|
|
|
data.text = group + '/' + PBS.Utils.render_datetime_utc(data["backup-time"]);
|
|
data.leaf = false;
|
|
data.cls = 'no-leaf-icons';
|
|
data.matchesFilter = true;
|
|
data.ty = 'dir';
|
|
|
|
data.expanded = !!expanded[data.text];
|
|
|
|
data.children = [];
|
|
for (const file of data.files) {
|
|
file.text = file.filename;
|
|
file['crypt-mode'] = PBS.Utils.cryptmap.indexOf(file['crypt-mode']);
|
|
file.fingerprint = data.fingerprint;
|
|
file.leaf = true;
|
|
file.matchesFilter = true;
|
|
file.ty = 'file';
|
|
|
|
data.children.push(file);
|
|
}
|
|
|
|
children.push(data);
|
|
}
|
|
|
|
let nowSeconds = Date.now() / 1000;
|
|
let children = [];
|
|
for (const [name, group] of Object.entries(groups)) {
|
|
let last_backup = 0;
|
|
let crypt = {
|
|
none: 0,
|
|
mixed: 0,
|
|
'sign-only': 0,
|
|
encrypt: 0,
|
|
};
|
|
let verify = {
|
|
outdated: 0,
|
|
none: 0,
|
|
failed: 0,
|
|
ok: 0,
|
|
};
|
|
for (let item of group.children) {
|
|
crypt[PBS.Utils.cryptmap[item['crypt-mode']]]++;
|
|
if (item["backup-time"] > last_backup && item.size !== null) {
|
|
last_backup = item["backup-time"];
|
|
group["backup-time"] = last_backup;
|
|
group.files = item.files;
|
|
group.size = item.size;
|
|
group.owner = item.owner;
|
|
verify.lastFailed = item.verification && item.verification.state !== 'ok';
|
|
}
|
|
if (!item.verification) {
|
|
verify.none++;
|
|
} else {
|
|
if (item.verification.state === 'ok') {
|
|
verify.ok++;
|
|
} else {
|
|
verify.failed++;
|
|
}
|
|
let task = Proxmox.Utils.parse_task_upid(item.verification.upid);
|
|
item.verification.lastTime = task.starttime;
|
|
if (nowSeconds - task.starttime > 30 * 24 * 60 * 60) {
|
|
verify.outdated++;
|
|
}
|
|
}
|
|
}
|
|
group.verification = verify;
|
|
group.count = group.children.length;
|
|
group.matchesFilter = true;
|
|
crypt.count = group.count;
|
|
group['crypt-mode'] = PBS.Utils.calculateCryptMode(crypt);
|
|
group.expanded = !!expanded[name];
|
|
group.sortWeight = 0;
|
|
group.ty = 'group';
|
|
children.push(group);
|
|
}
|
|
|
|
for (const item of namespaces) {
|
|
if (item.ns === view.namespace || (!view.namespace && item.ns === '')) {
|
|
continue;
|
|
}
|
|
children.push({
|
|
text: item.ns,
|
|
iconCls: 'fa fa-object-group',
|
|
expanded: true,
|
|
expandable: false,
|
|
ns: (view.namespaces ?? '') !== '' ? `/${item.ns}` : item.ns,
|
|
ty: 'ns',
|
|
sortWeight: 10,
|
|
//qtip: gettext('Double-click to browse namespace.'),
|
|
leaf: true,
|
|
});
|
|
}
|
|
|
|
let isRootNS = !view.namespace || view.namespace === '';
|
|
let rootText = isRootNS
|
|
? gettext('Root Namespace')
|
|
: Ext.String.format(gettext("Namespace '{0}'"), view.namespace);
|
|
|
|
let topNodes = [];
|
|
if (!isRootNS) {
|
|
let parentNS = view.namespace.split('/').slice(0, -1).join('/');
|
|
topNodes.push({
|
|
text: `.. (${parentNS === '' ? gettext('Root') : parentNS})`,
|
|
iconCls: 'fa fa-level-up',
|
|
//qtip: gettext('Double-click to go one namespace level up.'),
|
|
ty: 'ns',
|
|
ns: parentNS,
|
|
sortWeight: -10,
|
|
leaf: true,
|
|
});
|
|
}
|
|
topNodes.push({
|
|
text: rootText,
|
|
iconCls: "fa fa-" + (isRootNS ? 'database' : 'object-group'),
|
|
expanded: true,
|
|
expandable: false,
|
|
sortWeight: -5,
|
|
root: true, // fake root
|
|
ty: 'ns',
|
|
children: children,
|
|
});
|
|
|
|
view.setRootNode({
|
|
expanded: true,
|
|
children: topNodes,
|
|
});
|
|
|
|
if (!children.length) {
|
|
view.setEmptyText(Ext.String.format(
|
|
gettext('No accessible snapshots found in namespace {0}'),
|
|
view.namespace && view.namespace !== '' ? `'${view.namespace}'`: gettext('Root'),
|
|
));
|
|
}
|
|
|
|
this.updateGroupNotes(view);
|
|
|
|
if (selected !== undefined) {
|
|
let selection = view.getRootNode().findChildBy(function(item) {
|
|
let id = item.data.text;
|
|
if (item.data.leaf) {
|
|
id = item.parentNode.data.text + id;
|
|
}
|
|
return selected === id;
|
|
}, undefined, true);
|
|
if (selection) {
|
|
view.setSelection(selection);
|
|
view.getView().focusRow(selection);
|
|
}
|
|
}
|
|
|
|
Proxmox.Utils.setErrorMask(view, false);
|
|
if (view.getStore().getFilters().length > 0) {
|
|
let searchBox = me.lookup("searchbox");
|
|
let searchvalue = searchBox.getValue();
|
|
me.search(searchBox, searchvalue);
|
|
}
|
|
},
|
|
|
|
onChangeOwner: function(table, rI, cI, item, e, { data }) {
|
|
let view = this.getView();
|
|
|
|
if (data.ty !== 'group' || !view.datastore) {
|
|
return;
|
|
}
|
|
|
|
let win = Ext.create('PBS.BackupGroupChangeOwner', {
|
|
datastore: view.datastore,
|
|
ns: view.namespace,
|
|
backup_type: data.backup_type,
|
|
backup_id: data.backup_id,
|
|
owner: data.owner,
|
|
autoShow: true,
|
|
});
|
|
// FIXME: don't reload all, use the record and query only its info, then update it
|
|
// directly in the tree
|
|
win.on('destroy', this.reload, this);
|
|
},
|
|
|
|
onPrune: function(table, rI, cI, item, e, rec) {
|
|
let me = this;
|
|
let view = me.getView();
|
|
|
|
if (rec.data.ty !== 'group' || !view.datastore) {
|
|
return;
|
|
}
|
|
let data = rec.data;
|
|
Ext.create('PBS.DataStorePrune', {
|
|
autoShow: true,
|
|
datastore: view.datastore,
|
|
ns: view.namespace,
|
|
backup_type: data.backup_type,
|
|
backup_id: data.backup_id,
|
|
listeners: {
|
|
// FIXME: don't reload all, use the record and query only its info, then update
|
|
// it directly in the tree
|
|
destroy: () => me.reload(),
|
|
},
|
|
});
|
|
},
|
|
|
|
verifyAll: function() {
|
|
let me = this;
|
|
let view = me.getView();
|
|
|
|
Ext.create('PBS.window.VerifyAll', {
|
|
taskDone: () => me.reload(),
|
|
autoShow: true,
|
|
datastore: view.datastore,
|
|
namespace: view.namespace,
|
|
});
|
|
},
|
|
|
|
pruneAll: function() {
|
|
let me = this;
|
|
let view = me.getView();
|
|
|
|
if (!view.datastore) return;
|
|
|
|
let ns = view.namespace;
|
|
let titleNS = ns && ns !== '' ? `Namespace '${ns}' on ` : '';
|
|
|
|
Ext.create('Proxmox.window.Edit', {
|
|
title: `Prune ${titleNS}Datastore '${view.datastore}'`,
|
|
onlineHelp: 'maintenance_pruning',
|
|
method: 'POST',
|
|
submitText: "Prune",
|
|
autoShow: true,
|
|
isCreate: true,
|
|
showTaskViewer: true,
|
|
taskDone: () => me.reload(),
|
|
url: `/api2/extjs/admin/datastore/${view.datastore}/prune-datastore`,
|
|
items: [
|
|
{
|
|
xtype: 'pbsPruneInputPanel',
|
|
ns,
|
|
dryrun: true,
|
|
},
|
|
],
|
|
});
|
|
},
|
|
|
|
addNS: function() {
|
|
let me = this;
|
|
let view = me.getView();
|
|
if (!view.datastore) return;
|
|
|
|
Ext.create('PBS.window.NamespaceEdit', {
|
|
autoShow: true,
|
|
datastore: view.datastore,
|
|
namespace: view.namespace ?? '',
|
|
listeners: {
|
|
destroy: () => {
|
|
view.down('pbsNamespaceSelector').store?.load();
|
|
},
|
|
},
|
|
});
|
|
},
|
|
|
|
onVerify: function(view, rI, cI, item, e, { data }) {
|
|
let me = this;
|
|
view = me.getView();
|
|
|
|
if ((data.ty !== 'group' && data.ty !== 'dir') || !view.datastore) {
|
|
return;
|
|
}
|
|
|
|
let params;
|
|
if (data.ty === 'dir') {
|
|
params = {
|
|
"backup-type": data["backup-type"],
|
|
"backup-id": data["backup-id"],
|
|
"backup-time": (data['backup-time'].getTime()/1000).toFixed(0),
|
|
"outdated-after": 0, // always reverify single snapshots
|
|
};
|
|
} else {
|
|
params = {
|
|
"backup-type": data.backup_type,
|
|
"backup-id": data.backup_id,
|
|
"outdated-after": 29, // reverify after 29 days so match with the "old" display
|
|
};
|
|
}
|
|
if (view.namespace && view.namespace !== '') {
|
|
params.ns = view.namespace;
|
|
}
|
|
|
|
Proxmox.Utils.API2Request({
|
|
params: params,
|
|
url: `/admin/datastore/${view.datastore}/verify`,
|
|
method: 'POST',
|
|
failure: function(response) {
|
|
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
|
|
},
|
|
success: function(response, options) {
|
|
Ext.create('Proxmox.window.TaskViewer', {
|
|
upid: response.result.data,
|
|
taskDone: () => me.reload(),
|
|
}).show();
|
|
},
|
|
});
|
|
},
|
|
|
|
onNotesEdit: function(view, data) {
|
|
let me = this;
|
|
|
|
let isGroup = data.ty === 'group';
|
|
|
|
let params;
|
|
if (isGroup) {
|
|
params = {
|
|
"backup-type": data.backup_type,
|
|
"backup-id": data.backup_id,
|
|
};
|
|
} else {
|
|
params = {
|
|
"backup-type": data["backup-type"],
|
|
"backup-id": data["backup-id"],
|
|
"backup-time": (data['backup-time'].getTime()/1000).toFixed(0),
|
|
};
|
|
}
|
|
if (view.namespace && view.namespace !== '') {
|
|
params.ns = view.namespace;
|
|
}
|
|
|
|
Ext.create('PBS.window.NotesEdit', {
|
|
url: `/admin/datastore/${view.datastore}/${isGroup ? 'group-notes' : 'notes'}`,
|
|
autoShow: true,
|
|
apiCallDone: () => me.reload(), // FIXME: do something more efficient?
|
|
extraRequestParams: params,
|
|
});
|
|
},
|
|
|
|
forgetGroup: function(data) {
|
|
let me = this;
|
|
let view = me.getView();
|
|
|
|
let params = {
|
|
"backup-type": data.backup_type,
|
|
"backup-id": data.backup_id,
|
|
};
|
|
if (view.namespace && view.namespace !== '') {
|
|
params.ns = view.namespace;
|
|
}
|
|
|
|
Ext.create('Proxmox.window.SafeDestroy', {
|
|
url: `/admin/datastore/${view.datastore}/groups`,
|
|
params,
|
|
item: {
|
|
id: data.text,
|
|
},
|
|
autoShow: true,
|
|
taskName: 'forget-group',
|
|
listeners: {
|
|
destroy: () => me.reload(),
|
|
},
|
|
});
|
|
},
|
|
|
|
forgetSnapshot: function(data) {
|
|
let me = this;
|
|
let view = me.getView();
|
|
|
|
Ext.Msg.show({
|
|
title: gettext('Confirm'),
|
|
icon: Ext.Msg.WARNING,
|
|
message: Ext.String.format(gettext('Are you sure you want to remove snapshot {0}'), `'${data.text}'`),
|
|
buttons: Ext.Msg.YESNO,
|
|
defaultFocus: 'no',
|
|
callback: function(btn) {
|
|
if (btn !== 'yes') {
|
|
return;
|
|
}
|
|
let params = {
|
|
"backup-type": data["backup-type"],
|
|
"backup-id": data["backup-id"],
|
|
"backup-time": (data['backup-time'].getTime()/1000).toFixed(0),
|
|
};
|
|
if (view.namespace && view.namespace !== '') {
|
|
params.ns = view.namespace;
|
|
}
|
|
|
|
Proxmox.Utils.API2Request({
|
|
url: `/admin/datastore/${view.datastore}/snapshots`,
|
|
params,
|
|
method: 'DELETE',
|
|
waitMsgTarget: view,
|
|
failure: function(response, opts) {
|
|
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
|
|
},
|
|
callback: me.reload.bind(me),
|
|
});
|
|
},
|
|
});
|
|
},
|
|
|
|
onProtectionChange: function(view, rI, cI, item, e, rec) {
|
|
let me = this;
|
|
view = this.getView();
|
|
|
|
if (!(rec && rec.data)) return;
|
|
let data = rec.data;
|
|
if (!view.datastore) return;
|
|
|
|
let type = data["backup-type"];
|
|
let id = data["backup-id"];
|
|
let time = (data["backup-time"].getTime()/1000).toFixed(0);
|
|
|
|
let params = {
|
|
'backup-type': type,
|
|
'backup-id': id,
|
|
'backup-time': time,
|
|
};
|
|
if (view.namespace && view.namespace !== '') {
|
|
params.ns = view.namespace;
|
|
}
|
|
|
|
let url = `/api2/extjs/admin/datastore/${view.datastore}/protected`;
|
|
|
|
Ext.create('Proxmox.window.Edit', {
|
|
subject: gettext('Protection') + ` - ${data.text}`,
|
|
width: 400,
|
|
|
|
method: 'PUT',
|
|
autoShow: true,
|
|
isCreate: false,
|
|
autoLoad: true,
|
|
|
|
loadUrl: `${url}?${Ext.Object.toQueryString(params)}`,
|
|
url,
|
|
|
|
items: [
|
|
{
|
|
xtype: 'hidden',
|
|
name: 'backup-type',
|
|
value: type,
|
|
},
|
|
{
|
|
xtype: 'hidden',
|
|
name: 'backup-id',
|
|
value: id,
|
|
},
|
|
{
|
|
xtype: 'hidden',
|
|
name: 'backup-time',
|
|
value: time,
|
|
},
|
|
{
|
|
xtype: 'proxmoxcheckbox',
|
|
fieldLabel: gettext('Protected'),
|
|
uncheckedValue: 0,
|
|
name: 'protected',
|
|
value: data.protected,
|
|
},
|
|
],
|
|
listeners: {
|
|
destroy: () => me.reload(),
|
|
},
|
|
});
|
|
},
|
|
|
|
onForget: function(table, rI, cI, item, e, { data }) {
|
|
let me = this;
|
|
let view = this.getView();
|
|
if ((data.ty !== 'group' && data.ty !== 'dir') || !view.datastore) {
|
|
return;
|
|
}
|
|
|
|
if (data.ty === 'dir') {
|
|
me.forgetSnapshot(data);
|
|
} else {
|
|
me.forgetGroup(data);
|
|
}
|
|
},
|
|
|
|
downloadFile: function(tV, rI, cI, item, e, rec) {
|
|
let me = this;
|
|
let view = me.getView();
|
|
if (rec.data.ty !== 'file') return;
|
|
|
|
let snapshot = rec.parentNode.data;
|
|
let file = rec.data.filename;
|
|
let params = {
|
|
'backup-id': snapshot['backup-id'],
|
|
'backup-type': snapshot['backup-type'],
|
|
'backup-time': (snapshot['backup-time'].getTime()/1000).toFixed(0),
|
|
'file-name': file,
|
|
};
|
|
if (view.namespace && view.namespace !== '') {
|
|
params.ns = view.namespace;
|
|
}
|
|
|
|
let idx = file.lastIndexOf('.');
|
|
let filename = file.slice(0, idx);
|
|
let atag = document.createElement('a');
|
|
atag.download = filename;
|
|
let url = new URL(
|
|
`/api2/json/admin/datastore/${view.datastore}/download-decoded`,
|
|
window.location.origin,
|
|
);
|
|
for (const [key, value] of Object.entries(params)) {
|
|
url.searchParams.append(key, value);
|
|
}
|
|
atag.href = url.href;
|
|
atag.click();
|
|
},
|
|
|
|
// opens either a namespace or a pxar file-browser
|
|
openBrowser: function(tv, rI, Ci, item, e, rec) {
|
|
let me = this;
|
|
let view = me.getView();
|
|
|
|
if (rec.data.ty === 'ns') {
|
|
me.nsChange(null, rec.data.ns);
|
|
return;
|
|
}
|
|
if (rec?.data?.ty !== 'file') return;
|
|
let snapshot = rec.parentNode.data;
|
|
|
|
let id = snapshot['backup-id'];
|
|
let time = snapshot['backup-time'];
|
|
let type = snapshot['backup-type'];
|
|
let timetext = PBS.Utils.render_datetime_utc(snapshot["backup-time"]);
|
|
let extraParams = {
|
|
'backup-id': id,
|
|
'backup-time': (time.getTime()/1000).toFixed(0),
|
|
'backup-type': type,
|
|
};
|
|
if (view.namespace && view.namespace !== '') {
|
|
extraParams.ns = view.namespace;
|
|
}
|
|
Ext.create('Proxmox.window.FileBrowser', {
|
|
title: `${type}/${id}/${timetext}`,
|
|
listURL: `/api2/json/admin/datastore/${view.datastore}/catalog`,
|
|
downloadURL: `/api2/json/admin/datastore/${view.datastore}/pxar-file-download`,
|
|
enableTar: true,
|
|
extraParams,
|
|
archive: rec.data.filename,
|
|
}).show();
|
|
},
|
|
|
|
filter: function(item, value) {
|
|
if (item.data.text.indexOf(value) !== -1) {
|
|
return true;
|
|
}
|
|
|
|
if (item.data.owner && item.data.owner.indexOf(value) !== -1) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
},
|
|
|
|
search: function(tf, value) {
|
|
let me = this;
|
|
let view = me.getView();
|
|
let store = view.getStore();
|
|
if (!value && value !== 0) {
|
|
store.clearFilter();
|
|
// only collapse the children below our toplevel namespace "root"
|
|
store.getRoot().lastChild.collapseChildren(true);
|
|
tf.triggers.clear.setVisible(false);
|
|
return;
|
|
}
|
|
tf.triggers.clear.setVisible(true);
|
|
if (value.length < 2) return;
|
|
Proxmox.Utils.setErrorMask(view, true);
|
|
// we do it a little bit later for the error mask to work
|
|
setTimeout(function() {
|
|
store.clearFilter();
|
|
store.getRoot().collapseChildren(true);
|
|
|
|
store.beginUpdate();
|
|
store.getRoot().cascadeBy({
|
|
before: function(item) {
|
|
if (me.filter(item, value)) {
|
|
item.set('matchesFilter', true);
|
|
if (item.parentNode && item.parentNode.id !== 'root') {
|
|
item.parentNode.childmatches = true;
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
},
|
|
after: function(item) {
|
|
if (me.filter(item, value) || item.id === 'root' || item.childmatches) {
|
|
item.set('matchesFilter', true);
|
|
if (item.parentNode && item.parentNode.id !== 'root') {
|
|
item.parentNode.childmatches = true;
|
|
}
|
|
if (item.childmatches) {
|
|
item.expand();
|
|
}
|
|
} else {
|
|
item.set('matchesFilter', false);
|
|
}
|
|
delete item.childmatches;
|
|
},
|
|
});
|
|
store.endUpdate();
|
|
|
|
store.filter((item) => !!item.get('matchesFilter'));
|
|
Proxmox.Utils.setErrorMask(view, false);
|
|
}, 10);
|
|
},
|
|
},
|
|
|
|
listeners: {
|
|
activate: function() {
|
|
let me = this;
|
|
// only load on first activate to not load every tab switch
|
|
if (!me.firstLoad) {
|
|
me.getController().reload();
|
|
me.firstLoad = true;
|
|
}
|
|
},
|
|
},
|
|
|
|
viewConfig: {
|
|
getRowClass: function(record, index) {
|
|
let verify = record.get('verification');
|
|
if (verify && verify.lastFailed) {
|
|
return 'proxmox-invalid-row';
|
|
}
|
|
return null;
|
|
},
|
|
},
|
|
|
|
columns: [
|
|
{
|
|
xtype: 'treecolumn',
|
|
header: gettext("Backup Group"),
|
|
dataIndex: 'text',
|
|
renderer: (value, meta, record) => {
|
|
if (record.data.protected) {
|
|
return `${value} (${gettext('protected')})`;
|
|
}
|
|
return value;
|
|
},
|
|
flex: 1,
|
|
},
|
|
{
|
|
text: gettext('Comment'),
|
|
dataIndex: 'comment',
|
|
flex: 1,
|
|
renderer: (v, meta, record) => {
|
|
let data = record.data;
|
|
if (!data || data.leaf || data.root) {
|
|
return '';
|
|
}
|
|
if (v === undefined || v === null) {
|
|
v = '';
|
|
}
|
|
v = Ext.String.htmlEncode(v);
|
|
let icon = 'x-action-col-icon fa fa-fw fa-pencil pointer';
|
|
|
|
return `<span class="snapshot-comment-column">${v}</span>
|
|
<i data-qtip="${gettext('Edit')}" style="float: right; margin: 0px;" class="${icon}"></i>`;
|
|
},
|
|
listeners: {
|
|
afterrender: function(component) {
|
|
// a bit of a hack, but relatively easy, cheap and works out well.
|
|
// more efficient to use one handler for the whole column than for each icon
|
|
component.on('click', function(tree, cell, rowI, colI, e, rec) {
|
|
let el = e.target;
|
|
if (el.tagName !== "I" || !el.classList.contains("fa-pencil")) {
|
|
return;
|
|
}
|
|
let view = tree.up();
|
|
let controller = view.controller;
|
|
controller.onNotesEdit(view, rec.data);
|
|
});
|
|
},
|
|
dblclick: function(tree, el, row, col, ev, rec) {
|
|
let data = rec.data || {};
|
|
if (data.leaf || data.root) {
|
|
return;
|
|
}
|
|
let view = tree.up();
|
|
let controller = view.controller;
|
|
controller.onNotesEdit(view, rec.data);
|
|
},
|
|
},
|
|
},
|
|
{
|
|
header: gettext('Actions'),
|
|
xtype: 'actioncolumn',
|
|
dataIndex: 'text',
|
|
width: 150,
|
|
items: [
|
|
{
|
|
handler: 'onVerify',
|
|
getTip: (v, m, rec) => Ext.String.format(gettext("Verify '{0}'"), v),
|
|
getClass: (v, m, { data }) => data.ty === 'group' || data.ty === 'dir' ? 'pve-icon-verify-lettering' : 'pmx-hidden',
|
|
isActionDisabled: (v, r, c, i, rec) => !!rec.data.leaf,
|
|
},
|
|
{
|
|
handler: 'onChangeOwner',
|
|
getClass: (v, m, { data }) => data.ty === 'group' ? 'fa fa-user' : 'pmx-hidden',
|
|
getTip: (v, m, rec) => Ext.String.format(gettext("Change owner of '{0}'"), v),
|
|
isActionDisabled: (v, r, c, i, { data }) => data.ty !== 'group',
|
|
},
|
|
{
|
|
handler: 'onPrune',
|
|
getTip: (v, m, rec) => Ext.String.format(gettext("Prune '{0}'"), v),
|
|
getClass: (v, m, { data }) => data.ty === 'group' ? 'fa fa-scissors' : 'pmx-hidden',
|
|
isActionDisabled: (v, r, c, i, { data }) => data.ty !== 'group',
|
|
},
|
|
{
|
|
handler: 'onProtectionChange',
|
|
getTip: (v, m, rec) => Ext.String.format(gettext("Change protection of '{0}'"), v),
|
|
getClass: (v, m, rec) => {
|
|
if (rec.data.ty === 'dir') {
|
|
let extraCls = rec.data.protected ? 'good' : 'faded';
|
|
return `fa fa-shield ${extraCls}`;
|
|
}
|
|
return 'pmx-hidden';
|
|
},
|
|
isActionDisabled: (v, r, c, i, rec) => rec.data.ty !== 'dir',
|
|
},
|
|
{
|
|
handler: 'onForget',
|
|
getTip: (v, m, { data }) => data ==='dir'
|
|
? Ext.String.format(gettext("Permanently forget snapshot '{0}'"), v)
|
|
: Ext.String.format(gettext("Permanently forget group '{0}'"), v),
|
|
getClass: (v, m, { data }) =>
|
|
data.ty === 'group' || data.ty === 'dir' ? 'fa critical fa-trash-o' : 'pmx-hidden',
|
|
isActionDisabled: (v, r, c, i, { data }) => !(data.ty === 'group' || data.ty === 'dir'),
|
|
},
|
|
{
|
|
handler: 'downloadFile',
|
|
getTip: (v, m, rec) => Ext.String.format(gettext("Download '{0}'"), v),
|
|
getClass: (v, m, { data }) => data.ty === 'file' ? 'fa fa-download' : 'pmx-hidden',
|
|
isActionDisabled: (v, r, c, i, rec) => rec.data.ty !== 'file' || rec.data['crypt-mode'] > 2,
|
|
},
|
|
{
|
|
handler: 'openBrowser',
|
|
tooltip: gettext('Browse'),
|
|
getClass: (v, m, { data }) => {
|
|
if (
|
|
(data.ty === 'file' && data.filename.endsWith('pxar.didx')) ||
|
|
(data.ty === 'ns' && !data.root)
|
|
) {
|
|
return 'fa fa-folder-open-o';
|
|
}
|
|
return 'pmx-hidden';
|
|
},
|
|
isActionDisabled: (v, r, c, i, { data }) =>
|
|
!(data.ty === 'file' && data.filename.endsWith('pxar.didx') && data['crypt-mode'] < 3) && data.ty !== 'ns',
|
|
},
|
|
],
|
|
},
|
|
{
|
|
xtype: 'datecolumn',
|
|
header: gettext('Backup Time'),
|
|
sortable: true,
|
|
dataIndex: 'backup-time',
|
|
format: 'Y-m-d H:i:s',
|
|
width: 150,
|
|
},
|
|
{
|
|
header: gettext("Size"),
|
|
sortable: true,
|
|
dataIndex: 'size',
|
|
renderer: (v, meta, { data }) => {
|
|
if ((data.text === 'client.log.blob' && v === undefined) || (data.ty !== 'dir' && data.ty !== 'file')) {
|
|
return '';
|
|
}
|
|
if (v === undefined || v === null) {
|
|
meta.tdCls = "x-grid-row-loading";
|
|
return '';
|
|
}
|
|
return Proxmox.Utils.format_size(v);
|
|
},
|
|
},
|
|
{
|
|
xtype: 'numbercolumn',
|
|
format: '0',
|
|
header: gettext("Count"),
|
|
sortable: true,
|
|
width: 75,
|
|
align: 'right',
|
|
dataIndex: 'count',
|
|
},
|
|
{
|
|
header: gettext("Owner"),
|
|
sortable: true,
|
|
dataIndex: 'owner',
|
|
},
|
|
{
|
|
header: gettext('Encrypted'),
|
|
dataIndex: 'crypt-mode',
|
|
renderer: (v, meta, record) => {
|
|
if (record.data.size === undefined || record.data.size === null) {
|
|
return '';
|
|
}
|
|
if (v === -1) {
|
|
return '';
|
|
}
|
|
let iconCls = PBS.Utils.cryptIconCls[v] || '';
|
|
let iconTxt = "";
|
|
if (iconCls) {
|
|
iconTxt = `<i class="fa fa-fw fa-${iconCls}"></i> `;
|
|
}
|
|
let tip;
|
|
if (v !== PBS.Utils.cryptmap.indexOf('none') && record.data.fingerprint !== undefined) {
|
|
tip = "Key: " + PBS.Utils.renderKeyID(record.data.fingerprint);
|
|
}
|
|
let txt = (iconTxt + PBS.Utils.cryptText[v]) || Proxmox.Utils.unknownText;
|
|
if (record.data.ty === 'group' || tip === undefined) {
|
|
return txt;
|
|
} else {
|
|
return `<span data-qtip="${tip}">${txt}</span>`;
|
|
}
|
|
},
|
|
},
|
|
{
|
|
header: gettext('Verify State'),
|
|
sortable: true,
|
|
dataIndex: 'verification',
|
|
width: 120,
|
|
sorter: (arec, brec) => {
|
|
let a = arec.data.verification || { ok: 0, outdated: 0, failed: 0 };
|
|
let b = brec.data.verification || { ok: 0, outdated: 0, failed: 0 };
|
|
if (a.failed === b.failed) {
|
|
if (a.none === b.none) {
|
|
if (a.outdated === b.outdated) {
|
|
return b.ok - a.ok;
|
|
} else {
|
|
return b.outdated - a.outdated;
|
|
}
|
|
} else {
|
|
return b.none - a.none;
|
|
}
|
|
} else {
|
|
return b.failed - a.failed;
|
|
}
|
|
},
|
|
renderer: (v, meta, record) => {
|
|
if (record.data.ty === 'ns') {
|
|
return ''; // TODO: accumulate verify of all groups into root NS node?
|
|
}
|
|
let i = (cls, txt) => `<i class="fa fa-fw fa-${cls}"></i> ${txt}`;
|
|
if (v === undefined || v === null) {
|
|
return record.data.leaf ? '' : i('question-circle-o warning', gettext('None'));
|
|
}
|
|
let tip, iconCls, txt;
|
|
if (record.data.ty === 'group') {
|
|
if (v.failed === 0) {
|
|
if (v.none === 0) {
|
|
if (v.outdated > 0) {
|
|
tip = 'All OK, but some snapshots were not verified in last 30 days';
|
|
iconCls = 'check warning';
|
|
txt = gettext('All OK (old)');
|
|
} else {
|
|
tip = 'All snapshots verified at least once in last 30 days';
|
|
iconCls = 'check good';
|
|
txt = gettext('All OK');
|
|
}
|
|
} else if (v.ok === 0) {
|
|
tip = `${v.none} not verified yet`;
|
|
iconCls = 'question-circle-o warning';
|
|
txt = gettext('None');
|
|
} else {
|
|
tip = `${v.ok} OK, ${v.none} not verified yet`;
|
|
iconCls = 'check faded';
|
|
txt = `${v.ok} OK`;
|
|
}
|
|
} else {
|
|
tip = `${v.ok} OK, ${v.failed} failed, ${v.none} not verified yet`;
|
|
iconCls = 'times critical';
|
|
txt = v.ok === 0 && v.none === 0
|
|
? gettext('All failed')
|
|
: `${v.failed} failed`;
|
|
}
|
|
} else if (!v.state) {
|
|
return record.data.leaf ? '' : gettext('None');
|
|
} else {
|
|
let verify_time = Proxmox.Utils.render_timestamp(v.lastTime);
|
|
tip = `Last verify task started on ${verify_time}`;
|
|
txt = v.state;
|
|
iconCls = 'times critical';
|
|
if (v.state === 'ok') {
|
|
iconCls = 'check good';
|
|
let now = Date.now() / 1000;
|
|
if (now - v.lastTime > 30 * 24 * 60 * 60) {
|
|
tip = `Last verify task over 30 days ago: ${verify_time}`;
|
|
iconCls = 'check warning';
|
|
}
|
|
}
|
|
}
|
|
return `<span data-qtip="${tip}">
|
|
<i class="fa fa-fw fa-${iconCls}"></i> ${txt}
|
|
</span>`;
|
|
},
|
|
listeners: {
|
|
dblclick: function(view, el, row, col, ev, rec) {
|
|
let verify = rec?.data?.verification;
|
|
if (verify?.upid && rec.parentNode?.id !== 'root') {
|
|
Ext.create('Proxmox.window.TaskViewer', {
|
|
autoShow: true,
|
|
upid: verify.upid,
|
|
});
|
|
}
|
|
},
|
|
},
|
|
},
|
|
],
|
|
|
|
tbar: [
|
|
{
|
|
text: gettext('Reload'),
|
|
iconCls: 'fa fa-refresh',
|
|
handler: 'reload',
|
|
},
|
|
'-',
|
|
{
|
|
xtype: 'proxmoxButton',
|
|
text: gettext('Verify All'),
|
|
handler: 'verifyAll',
|
|
},
|
|
{
|
|
xtype: 'proxmoxButton',
|
|
text: gettext('Prune All'),
|
|
handler: 'pruneAll',
|
|
},
|
|
'->',
|
|
{
|
|
xtype: 'tbtext',
|
|
html: gettext('Namespace') + ':',
|
|
},
|
|
{
|
|
xtype: 'pbsNamespaceSelector',
|
|
width: 200,
|
|
cbind: {
|
|
datastore: '{datastore}',
|
|
},
|
|
},
|
|
{
|
|
xtype: 'proxmoxButton',
|
|
text: gettext('Add NS'),
|
|
iconCls: 'fa fa-plus-square',
|
|
handler: 'addNS',
|
|
},
|
|
'-',
|
|
{
|
|
xtype: 'tbtext',
|
|
html: gettext('Search'),
|
|
},
|
|
{
|
|
xtype: 'textfield',
|
|
reference: 'searchbox',
|
|
emptyText: gettext('group, date or owner'),
|
|
triggers: {
|
|
clear: {
|
|
cls: 'pmx-clear-trigger',
|
|
weight: -1,
|
|
hidden: true,
|
|
handler: function() {
|
|
this.triggers.clear.setVisible(false);
|
|
this.setValue('');
|
|
},
|
|
},
|
|
},
|
|
listeners: {
|
|
change: {
|
|
fn: 'search',
|
|
buffer: 500,
|
|
},
|
|
},
|
|
},
|
|
],
|
|
});
|