452 lines
10 KiB
JavaScript
452 lines
10 KiB
JavaScript
Ext.define('pbs-data-store-snapshots', {
|
|
extend: 'Ext.data.Model',
|
|
fields: [
|
|
'backup-type',
|
|
'backup-id',
|
|
{
|
|
name: 'backup-time',
|
|
type: 'date',
|
|
dateFormat: 'timestamp'
|
|
},
|
|
'files',
|
|
'owner',
|
|
{ name: 'size', type: 'int', allowNull: true, },
|
|
{
|
|
name: 'crypt-mode',
|
|
type: 'boolean',
|
|
calculate: function(data) {
|
|
let encrypted = 0;
|
|
let crypt = {
|
|
none: 0,
|
|
mixed: 0,
|
|
'sign-only': 0,
|
|
encrypt: 0,
|
|
count: 0,
|
|
};
|
|
let signed = 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);
|
|
}
|
|
}
|
|
]
|
|
});
|
|
|
|
Ext.define('PBS.DataStoreContent', {
|
|
extend: 'Ext.tree.Panel',
|
|
alias: 'widget.pbsDataStoreContent',
|
|
|
|
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([
|
|
'backup-group',
|
|
'text',
|
|
'backup-time'
|
|
]);
|
|
Proxmox.Utils.monStoreErrors(view, this.store);
|
|
this.reload(); // initial load
|
|
},
|
|
|
|
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`;
|
|
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 = '';
|
|
if (btype === 'vm') {
|
|
cls = 'fa-desktop';
|
|
} else if (btype === 'ct') {
|
|
cls = 'fa-cube';
|
|
} else if (btype === 'host') {
|
|
cls = 'fa-building';
|
|
} else {
|
|
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;
|
|
},
|
|
|
|
onLoad: function(store, records, success, operation) {
|
|
let view = this.getView();
|
|
|
|
if (!success) {
|
|
Proxmox.Utils.setErrorMask(view, Proxmox.Utils.getResponseErrorMessage(operation.getError()));
|
|
return;
|
|
}
|
|
|
|
let groups = this.getRecordGroups(records);
|
|
|
|
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 = true;
|
|
data.cls = 'no-leaf-icons';
|
|
|
|
children.push(data);
|
|
}
|
|
|
|
let children = [];
|
|
for (const [_key, group] of Object.entries(groups)) {
|
|
let last_backup = 0;
|
|
let crypt = {
|
|
none: 0,
|
|
mixed: 0,
|
|
'sign-only': 0,
|
|
encrypt: 0,
|
|
};
|
|
for (const 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;
|
|
}
|
|
|
|
}
|
|
group.count = group.children.length;
|
|
crypt.count = group.count;
|
|
group['crypt-mode'] = PBS.Utils.calculateCryptMode(crypt);
|
|
children.push(group);
|
|
}
|
|
|
|
view.setRootNode({
|
|
expanded: true,
|
|
children: children
|
|
});
|
|
Proxmox.Utils.setErrorMask(view, false);
|
|
},
|
|
|
|
onPrune: function() {
|
|
var view = this.getView();
|
|
|
|
let rec = view.selModel.getSelection()[0];
|
|
if (!(rec && rec.data)) return;
|
|
let data = rec.data;
|
|
if (data.leaf) return;
|
|
|
|
if (!view.datastore) return;
|
|
|
|
let win = Ext.create('PBS.DataStorePrune', {
|
|
datastore: view.datastore,
|
|
backup_type: data.backup_type,
|
|
backup_id: data.backup_id,
|
|
});
|
|
win.on('destroy', this.reload, this);
|
|
win.show();
|
|
},
|
|
|
|
onVerify: function() {
|
|
var view = this.getView();
|
|
|
|
if (!view.datastore) return;
|
|
|
|
let rec = view.selModel.getSelection()[0];
|
|
if (!(rec && rec.data)) return;
|
|
let data = rec.data;
|
|
|
|
let params;
|
|
|
|
if (data.leaf) {
|
|
params = {
|
|
"backup-type": data["backup-type"],
|
|
"backup-id": data["backup-id"],
|
|
"backup-time": (data['backup-time'].getTime()/1000).toFixed(0),
|
|
};
|
|
} else {
|
|
params = {
|
|
"backup-type": data.backup_type,
|
|
"backup-id": data.backup_id,
|
|
};
|
|
}
|
|
|
|
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,
|
|
}).show();
|
|
},
|
|
});
|
|
},
|
|
|
|
onForget: function() {
|
|
var view = this.getView();
|
|
|
|
let rec = view.selModel.getSelection()[0];
|
|
if (!(rec && rec.data)) return;
|
|
let data = rec.data;
|
|
if (!data.leaf) return;
|
|
|
|
if (!view.datastore) return;
|
|
|
|
console.log(data);
|
|
|
|
Proxmox.Utils.API2Request({
|
|
params: {
|
|
"backup-type": data["backup-type"],
|
|
"backup-id": data["backup-id"],
|
|
"backup-time": (data['backup-time'].getTime()/1000).toFixed(0),
|
|
},
|
|
url: `/admin/datastore/${view.datastore}/snapshots`,
|
|
method: 'DELETE',
|
|
waitMsgTarget: view,
|
|
failure: function(response, opts) {
|
|
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
|
|
},
|
|
callback: this.reload.bind(this),
|
|
});
|
|
},
|
|
|
|
openBackupFileDownloader: function() {
|
|
let me = this;
|
|
let view = me.getView();
|
|
|
|
let rec = view.selModel.getSelection()[0];
|
|
if (!(rec && rec.data)) return;
|
|
let data = rec.data;
|
|
|
|
Ext.create('PBS.window.BackupFileDownloader', {
|
|
baseurl: `/api2/json/admin/datastore/${view.datastore}`,
|
|
params: {
|
|
'backup-id': data['backup-id'],
|
|
'backup-type': data['backup-type'],
|
|
'backup-time': (data['backup-time'].getTime()/1000).toFixed(0),
|
|
},
|
|
files: data.files,
|
|
}).show();
|
|
},
|
|
|
|
openPxarBrowser: function() {
|
|
let me = this;
|
|
let view = me.getView();
|
|
|
|
let rec = view.selModel.getSelection()[0];
|
|
if (!(rec && rec.data)) return;
|
|
let data = rec.data;
|
|
|
|
let encrypted = false;
|
|
data.files.forEach(file => {
|
|
if (file.filename === 'catalog.pcat1.didx' && file['crypt-mode'] === 'encrypt') {
|
|
encrypted = true;
|
|
}
|
|
});
|
|
|
|
if (encrypted) {
|
|
Ext.Msg.alert(
|
|
gettext('Cannot open Catalog'),
|
|
gettext('Only unencrypted Backups can be opened on the server. Please use the client with the decryption key instead.'),
|
|
);
|
|
return;
|
|
}
|
|
|
|
let id = data['backup-id'];
|
|
let time = data['backup-time'];
|
|
let type = data['backup-type'];
|
|
let timetext = PBS.Utils.render_datetime_utc(data["backup-time"]);
|
|
|
|
Ext.create('PBS.window.FileBrowser', {
|
|
title: `${type}/${id}/${timetext}`,
|
|
datastore: view.datastore,
|
|
'backup-id': id,
|
|
'backup-time': (time.getTime()/1000).toFixed(0),
|
|
'backup-type': type,
|
|
}).show();
|
|
}
|
|
},
|
|
|
|
columns: [
|
|
{
|
|
xtype: 'treecolumn',
|
|
header: gettext("Backup Group"),
|
|
dataIndex: 'text',
|
|
flex: 1
|
|
},
|
|
{
|
|
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, record) => {
|
|
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,
|
|
dataIndex: 'count',
|
|
},
|
|
{
|
|
header: gettext("Owner"),
|
|
sortable: true,
|
|
dataIndex: 'owner',
|
|
},
|
|
{
|
|
header: gettext('Encrypted'),
|
|
dataIndex: 'crypt-mode',
|
|
renderer: value => PBS.Utils.cryptText[value] || Proxmox.Utils.unknownText,
|
|
},
|
|
{
|
|
header: gettext("Files"),
|
|
sortable: false,
|
|
dataIndex: 'files',
|
|
renderer: function(files) {
|
|
return files.map((file) => {
|
|
let icon = '';
|
|
let size = '';
|
|
let mode = PBS.Utils.cryptmap.indexOf(file['crypt-mode']);
|
|
let iconCls = PBS.Utils.cryptIconCls[mode] || '';
|
|
if (iconCls !== '') {
|
|
icon = `<i class="fa fa-${iconCls}"></i> `;
|
|
}
|
|
if (file.size) {
|
|
size = ` (${Proxmox.Utils.format_size(file.size)})`;
|
|
}
|
|
return `${icon}${file.filename}${size}`;
|
|
}).join(', ');
|
|
},
|
|
flex: 2
|
|
},
|
|
],
|
|
|
|
tbar: [
|
|
{
|
|
text: gettext('Reload'),
|
|
iconCls: 'fa fa-refresh',
|
|
handler: 'reload',
|
|
},
|
|
'-',
|
|
{
|
|
xtype: 'proxmoxButton',
|
|
text: gettext('Verify'),
|
|
disabled: true,
|
|
parentXType: 'pbsDataStoreContent',
|
|
enableFn: (rec) => !!rec.data && rec.data.size !== null,
|
|
handler: 'onVerify',
|
|
},
|
|
{
|
|
xtype: 'proxmoxButton',
|
|
text: gettext('Prune'),
|
|
disabled: true,
|
|
parentXType: 'pbsDataStoreContent',
|
|
enableFn: (rec) => !rec.data.leaf,
|
|
handler: 'onPrune',
|
|
},
|
|
{
|
|
xtype: 'proxmoxButton',
|
|
text: gettext('Forget'),
|
|
disabled: true,
|
|
parentXType: 'pbsDataStoreContent',
|
|
handler: 'onForget',
|
|
dangerous: true,
|
|
confirmMsg: function(record) {
|
|
//console.log(record);
|
|
let name = record.data.text;
|
|
return Ext.String.format(gettext('Are you sure you want to remove snapshot {0}'), `'${name}'`);
|
|
},
|
|
enableFn: (rec) => !!rec.data.leaf && rec.data.size !== null,
|
|
},
|
|
'-',
|
|
{
|
|
xtype: 'proxmoxButton',
|
|
text: gettext('Download Files'),
|
|
disabled: true,
|
|
parentXType: 'pbsDataStoreContent',
|
|
handler: 'openBackupFileDownloader',
|
|
enableFn: (rec) => !!rec.data.leaf && rec.data.size !== null,
|
|
},
|
|
{
|
|
xtype: "proxmoxButton",
|
|
text: gettext('PXAR File Browser'),
|
|
disabled: true,
|
|
handler: 'openPxarBrowser',
|
|
parentXType: 'pbsDataStoreContent',
|
|
enableFn: function(record) {
|
|
return !!record.data.leaf && record.size !== null && record.data.files.some(el => el.filename.endsWith('pxar.didx'));
|
|
},
|
|
}
|
|
],
|
|
});
|