diff --git a/docs/prune-simulator/documentation.html b/docs/prune-simulator/documentation.html
new file mode 100644
index 00000000..2bd90b94
--- /dev/null
+++ b/docs/prune-simulator/documentation.html
@@ -0,0 +1,73 @@
+
+
+
+
+
+
+A simulator to experiment with different backup schedules and prune
+options.
+
+Schedule
+Select weekdays with the combobox and input hour and minute
+specification separated by a colon, i.e. HOUR:MINUTE. Each of
+HOUR and MINUTE can be either a single value or
+one of the following:
+
+a comma-separated list: e.g., 01,02,03
+a range: e.g., 01..10
+a repetition: e.g, 05/10 (means starting at 5 every 10)
+a combination of the above: e.g., 01,05..10,12/02
+a * for every possible value
+
+
+Pruning
+Prune lets you systematically delete older backups, retaining backups for
+the last given number of time intervals. The following retention options are
+available:
+
+keep-last <N> Keep the last <N>
+keep-hourly <N> Keep backups for the last <N>
+keep-daily <N> Keep backups for the last <N>
+keep-weekly <N> Keep backups for the last <N>
+
Note: Weeks start on Monday and end on Sunday. The software
+uses the ISO week date system and handles weeks at
+the end of the year correctly.
+
+keep-monthly <N> Keep backups for the last <N>
+keep-yearly <N> Keep backups for the last <N>
+
+The retention options are processed in the order given above. Each option
+only covers backups within its time period. The next option does not take care
+of already covered backups. It will only consider older backups.
+For example, in a week covered by keep-weekly, one backup is
+kept while all others are removed; keep-monthly then does not
+consider backups from that week anymore, even if part of the week is part of
+an earlier month.
+
+
diff --git a/docs/prune-simulator/index.html b/docs/prune-simulator/index.html
new file mode 100644
index 00000000..22fa66f6
--- /dev/null
+++ b/docs/prune-simulator/index.html
@@ -0,0 +1,13 @@
+
+
+
+ PBS Prune Simulator
+
+ ',
+ '{value}',
+ ' ',
+ ],
+ });
+
+ Ext.define('PBS.prunesimulator.DayOfWeekSelector', {
+ extend: 'Ext.form.field.ComboBox',
+ alias: 'widget.prunesimulatorDayOfWeekSelector',
+
+ editable: false,
+
+ displayField: 'text',
+ valueField: 'value',
+ queryMode: 'local',
+
+ store: {
+ field: ['value', 'text'],
+ data: [
+ { value: 'mon', text: Ext.util.Format.htmlDecode(Ext.Date.dayNames[1]) },
+ { value: 'tue', text: Ext.util.Format.htmlDecode(Ext.Date.dayNames[2]) },
+ { value: 'wed', text: Ext.util.Format.htmlDecode(Ext.Date.dayNames[3]) },
+ { value: 'thu', text: Ext.util.Format.htmlDecode(Ext.Date.dayNames[4]) },
+ { value: 'fri', text: Ext.util.Format.htmlDecode(Ext.Date.dayNames[5]) },
+ { value: 'sat', text: Ext.util.Format.htmlDecode(Ext.Date.dayNames[6]) },
+ { value: 'sun', text: Ext.util.Format.htmlDecode(Ext.Date.dayNames[0]) },
+ ],
+ },
+ });
+
+ Ext.define('pbs-prune-list', {
+ extend: 'Ext.data.Model',
+ fields: [
+ {
+ name: 'backuptime',
+ type: 'date',
+ dateFormat: 'timestamp',
+ },
+ {
+ name: 'mark',
+ type: 'string',
+ },
+ {
+ name: 'keepName',
+ type: 'string',
+ },
+ ],
+ });
+
+ Ext.define('PBS.prunesimulator.PruneList', {
+ extend: 'Ext.panel.Panel',
+ alias: 'widget.prunesimulatorPruneList',
+
+ initComponent: function() {
+ var me = this;
+
+ if (!me.store) {
+ throw "no store specified";
+ }
+
+ me.items = [
+ {
+ xtype: 'grid',
+ store: me.store,
+ columns: [
+ {
+ header: 'Backup Time',
+ dataIndex: 'backuptime',
+ renderer: function(value, metaData, record) {
+ let text = Ext.Date.format(value, 'Y-m-d H:i:s');
+ if (record.data.mark === 'keep') {
+ if (me.useColors) {
+ let bgColor = COLORS[record.data.keepName];
+ let textColor = TEXT_COLORS[record.data.keepName];
+ return '' + text + '
';
+ } else {
+ return text;
+ }
+ } else {
+ return '' + text + '
';
+ }
+ },
+ flex: 1,
+ sortable: false,
+ },
+ {
+ header: 'Keep (reason)',
+ dataIndex: 'mark',
+ renderer: function(value, metaData, record) {
+ if (record.data.mark === 'keep') {
+ return 'keep (' + record.data.keepName + ')';
+ } else {
+ return value;
+ }
+ },
+ width: 200,
+ sortable: false,
+ },
+ ],
+ },
+ ];
+
+ me.callParent();
+ },
+ });
+
+ Ext.define('PBS.prunesimulator.WeekTable', {
+ extend: 'Ext.panel.Panel',
+ alias: 'widget.prunesimulatorWeekTable',
+
+ reload: function() {
+ let me = this;
+ let backups = me.store.data.items;
+
+ let html = '';
+
+ let now = new Date(NOW.getTime());
+ let skip = 7 - parseInt(Ext.Date.format(now, 'N'), 10);
+ let tableStartDate = Ext.Date.add(now, Ext.Date.DAY, skip);
+
+ let bIndex = 0;
+
+ for (let i = 0; bIndex < backups.length; i++) {
+ html += '';
+
+ for (let j = 0; j < 7; j++) {
+ html += '';
+
+ let date = Ext.Date.subtract(tableStartDate, Ext.Date.DAY, j + 7 * i);
+ let currentDay = Ext.Date.format(date, 'd/m/Y');
+
+ let isBackupOnDay = function(backup, day) {
+ return backup && Ext.Date.format(backup.data.backuptime, 'd/m/Y') === day;
+ };
+
+ let backup = backups[bIndex];
+
+ html += '' +
+ Ext.Date.format(date, 'D, d M Y') + ' ';
+
+ while (isBackupOnDay(backup, currentDay)) {
+ html += '';
+
+ let text = Ext.Date.format(backup.data.backuptime, 'H:i');
+ if (backup.data.mark === 'remove') {
+ html += '' + text + '
';
+ } else {
+ text += ' (' + backup.data.keepName + ')';
+ if (me.useColors) {
+ let bgColor = COLORS[backup.data.keepName];
+ let textColor = TEXT_COLORS[backup.data.keepName];
+ html += '' + text + '
';
+ } else {
+ html += '' + text + '
';
+ }
+ }
+ html += '
';
+ html += '';
+ html += ' ';
+ }
+
+ html += ' ';
+ }
+
+ me.setHtml(html);
+ },
+
+ initComponent: function() {
+ let me = this;
+
+ if (!me.store) {
+ throw "no store specified";
+ }
+
+ let reload = function() {
+ me.reload();
+ };
+
+ me.store.on("datachanged", reload);
+
+ me.callParent();
+
+ me.reload();
+ },
+ });
+
+ Ext.define('PBS.PruneSimulatorPanel', {
+ extend: 'Ext.panel.Panel',
+ alias: 'widget.prunesimulatorPanel',
+
+ viewModel: {
+ formulas: {
+ calendarHidden: function(get) {
+ return !get('showCalendar.checked');
+ },
+ },
+ },
+
+ getValues: function() {
+ let me = this;
+
+ let values = {};
+
+ Ext.Array.each(me.query('[isFormField]'), function(field) {
+ let data = field.getSubmitData();
+ Ext.Object.each(data, function(name, val) {
+ values[name] = val;
+ });
+ });
+
+ return values;
+ },
+
+ controller: {
+ xclass: 'Ext.app.ViewController',
+
+ init: function(view) {
+ this.reloadFull(); // initial load
+ },
+
+ control: {
+ 'field[fieldGroup=keep]': { change: 'reloadPrune' },
+ },
+
+ reloadFull: function() {
+ let me = this;
+ let view = me.getView();
+
+ let params = view.getValues();
+
+ let [hourSpec, minuteSpec] = params['schedule-time'].split(':');
+
+ if (!hourSpec || !minuteSpec) {
+ Ext.Msg.alert('Error', 'Invalid schedule');
+ return;
+ }
+
+ let matchTimeSpec = function(timeSpec, rangeMin, rangeMax) {
+ let specValues = timeSpec.split(',');
+ let matches = {};
+
+ let assertValid = function(value) {
+ let num = Number(value);
+ if (isNaN(num)) {
+ throw value + " is not an integer";
+ } else if (value < rangeMin || value > rangeMax) {
+ throw "number '" + value + "' is not in the range '" + rangeMin + ".." + rangeMax + "'";
+ }
+ return num;
+ };
+
+ specValues.forEach(function(value) {
+ if (value.includes('..')) {
+ let [start, end] = value.split('..');
+ start = assertValid(start);
+ end = assertValid(end);
+ if (start > end) {
+ throw "interval start is bigger then interval end '" + start + " > " + end + "'";
+ }
+ for (let i = start; i <= end; i++) {
+ matches[i] = 1;
+ }
+ } else if (value.includes('/')) {
+ let [start, step] = value.split('/');
+ start = assertValid(start);
+ step = assertValid(step);
+ for (let i = start; i <= rangeMax; i += step) {
+ matches[i] = 1;
+ }
+ } else if (value === '*') {
+ for (let i = rangeMin; i <= rangeMax; i++) {
+ matches[i] = 1;
+ }
+ } else {
+ value = assertValid(value);
+ matches[value] = 1;
+ }
+ });
+
+ return Object.keys(matches);
+ };
+
+ let hours, minutes;
+
+ try {
+ hours = matchTimeSpec(hourSpec, 0, 23);
+ minutes = matchTimeSpec(minuteSpec, 0, 59);
+ } catch (err) {
+ Ext.Msg.alert('Error', err);
+ }
+
+ let backups = me.populateFromSchedule(
+ params['schedule-weekdays'],
+ hours,
+ minutes,
+ params.numberOfWeeks,
+ );
+
+ me.pruneSelect(backups, params);
+
+ view.pruneStore.setData(backups);
+ },
+
+ reloadPrune: function() {
+ let me = this;
+ let view = me.getView();
+
+ let params = view.getValues();
+
+ let backups = [];
+ view.pruneStore.getData().items.forEach(function(item) {
+ backups.push({
+ backuptime: item.data.backuptime,
+ });
+ });
+
+ me.pruneSelect(backups, params);
+
+ view.pruneStore.setData(backups);
+ },
+
+ // backups are sorted descending by date
+ populateFromSchedule: function(weekdays, hours, minutes, weekCount) {
+ let weekdayFlags = [
+ weekdays.includes('sun'),
+ weekdays.includes('mon'),
+ weekdays.includes('tue'),
+ weekdays.includes('wed'),
+ weekdays.includes('thu'),
+ weekdays.includes('fri'),
+ weekdays.includes('sat'),
+ ];
+
+ let todaysDate = new Date(NOW.getTime());
+
+ let timesOnSingleDay = [];
+
+ hours.forEach(function(hour) {
+ minutes.forEach(function(minute) {
+ todaysDate.setHours(hour);
+ todaysDate.setMinutes(minute);
+ timesOnSingleDay.push(todaysDate.getTime());
+ });
+ });
+
+ // ordering here and iterating backwards through days
+ // ensures that everything is ordered
+ timesOnSingleDay.sort(function(a, b) {
+ return a < b;
+ });
+
+ let backups = [];
+
+ for (let i = 0; i < 7 * weekCount; i++) {
+ let daysDate = Ext.Date.subtract(todaysDate, Ext.Date.DAY, i);
+ let weekday = parseInt(Ext.Date.format(daysDate, 'w'), 10);
+ if (weekdayFlags[weekday]) {
+ timesOnSingleDay.forEach(function(time) {
+ backups.push({
+ backuptime: Ext.Date.subtract(new Date(time), Ext.Date.DAY, i),
+ });
+ });
+ }
+ }
+
+ return backups;
+ },
+
+ pruneMark: function(backups, keepCount, keepName, idFunc) {
+ if (!keepCount) {
+ return;
+ }
+
+ let alreadyIncluded = {};
+ let newlyIncluded = {};
+ let newlyIncludedCount = 0;
+
+ let finished = false;
+
+ backups.forEach(function(backup) {
+ let mark = backup.mark;
+ let id = idFunc(backup);
+
+ if (finished || alreadyIncluded[id]) {
+ return;
+ }
+
+ if (mark) {
+ if (mark === 'keep') {
+ alreadyIncluded[id] = true;
+ }
+ return;
+ }
+
+ if (!newlyIncluded[id]) {
+ if (newlyIncludedCount >= keepCount) {
+ finished = true;
+ return;
+ }
+ newlyIncluded[id] = true;
+ newlyIncludedCount++;
+ backup.mark = 'keep';
+ backup.keepName = keepName;
+ } else {
+ backup.mark = 'remove';
+ }
+ });
+ },
+
+ // backups need to be sorted descending by date
+ pruneSelect: function(backups, keepParams) {
+ let me = this;
+
+ if (Number(keepParams['keep-last']) +
+ Number(keepParams['keep-hourly']) +
+ Number(keepParams['keep-daily']) +
+ Number(keepParams['keep-weekly']) +
+ Number(keepParams['keep-monthly']) +
+ Number(keepParams['keep-yearly']) === 0) {
+ backups.forEach(function(backup) {
+ backup.mark = 'keep';
+ backup.keepName = 'all zero';
+ });
+
+ return;
+ }
+
+ me.pruneMark(backups, keepParams['keep-last'], 'keep-last', function(backup) {
+ return backup.backuptime;
+ });
+ me.pruneMark(backups, keepParams['keep-hourly'], 'keep-hourly', function(backup) {
+ return Ext.Date.format(backup.backuptime, 'H/d/m/Y');
+ });
+ me.pruneMark(backups, keepParams['keep-daily'], 'keep-daily', function(backup) {
+ return Ext.Date.format(backup.backuptime, 'd/m/Y');
+ });
+ me.pruneMark(backups, keepParams['keep-weekly'], 'keep-weekly', function(backup) {
+ // ISO-8601 week and week-based year
+ return Ext.Date.format(backup.backuptime, 'W/o');
+ });
+ me.pruneMark(backups, keepParams['keep-monthly'], 'keep-monthly', function(backup) {
+ return Ext.Date.format(backup.backuptime, 'm/Y');
+ });
+ me.pruneMark(backups, keepParams['keep-yearly'], 'keep-yearly', function(backup) {
+ return Ext.Date.format(backup.backuptime, 'Y');
+ });
+
+ backups.forEach(function(backup) {
+ backup.mark = backup.mark || 'remove';
+ });
+ },
+ },
+
+ keepItems: [
+ {
+ xtype: 'numberfield',
+ name: 'keep-last',
+ allowBlank: true,
+ fieldLabel: 'keep-last',
+ minValue: 0,
+ value: 4,
+ fieldGroup: 'keep',
+ padding: '0 0 0 10',
+ },
+ {
+ xtype: 'numberfield',
+ name: 'keep-hourly',
+ allowBlank: true,
+ fieldLabel: 'keep-hourly',
+ minValue: 0,
+ value: 0,
+ fieldGroup: 'keep',
+ padding: '0 0 0 10',
+ },
+ {
+ xtype: 'numberfield',
+ name: 'keep-daily',
+ allowBlank: true,
+ fieldLabel: 'keep-daily',
+ minValue: 0,
+ value: 5,
+ fieldGroup: 'keep',
+ padding: '0 0 0 10',
+ },
+ {
+ xtype: 'numberfield',
+ name: 'keep-weekly',
+ allowBlank: true,
+ fieldLabel: 'keep-weekly',
+ minValue: 0,
+ value: 2,
+ fieldGroup: 'keep',
+ padding: '0 0 0 10',
+ },
+ {
+ xtype: 'numberfield',
+ name: 'keep-monthly',
+ allowBlank: true,
+ fieldLabel: 'keep-monthly',
+ minValue: 0,
+ value: 0,
+ fieldGroup: 'keep',
+ padding: '0 0 0 10',
+ },
+ {
+ xtype: 'numberfield',
+ name: 'keep-yearly',
+ allowBlank: true,
+ fieldLabel: 'keep-yearly',
+ minValue: 0,
+ value: 0,
+ fieldGroup: 'keep',
+ padding: '0 0 0 10',
+ },
+ ],
+
+ initComponent: function() {
+ var me = this;
+
+ me.pruneStore = Ext.create('Ext.data.Store', {
+ model: 'pbs-prune-list',
+ sorters: { property: 'backuptime', direction: 'DESC' },
+ });
+
+ let scheduleItems = [
+ {
+ xtype: 'prunesimulatorDayOfWeekSelector',
+ name: 'schedule-weekdays',
+ fieldLabel: 'Day of week',
+ value: ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun'],
+ allowBlank: false,
+ multiSelect: true,
+ padding: '0 0 0 10',
+ },
+ {
+ xtype: 'prunesimulatorCalendarEvent',
+ name: 'schedule-time',
+ allowBlank: false,
+ value: '0/6:00',
+ fieldLabel: 'Backup schedule',
+ padding: '0 0 0 10',
+ },
+ {
+ xtype: 'numberfield',
+ name: 'numberOfWeeks',
+ allowBlank: false,
+ fieldLabel: 'Number of weeks',
+ minValue: 1,
+ value: 15,
+ maxValue: 200,
+ padding: '0 0 0 10',
+ },
+ {
+ xtype: 'button',
+ name: 'schedule-button',
+ text: 'Update Schedule',
+ handler: function() {
+ me.controller.reloadFull();
+ },
+ },
+ ];
+
+ me.items = [
+ {
+ xtype: 'panel',
+ layout: 'hbox',
+ height: 180,
+ items: [
+ {
+ title: 'View',
+ layout: 'anchor',
+ flex: 1,
+ items: [
+ {
+ padding: '0 0 0 10',
+ xtype: 'checkbox',
+ name: 'showCalendar',
+ reference: 'showCalendar',
+ fieldLabel: 'Show Calendar:',
+ checked: false,
+ },
+ {
+ padding: '0 0 0 10',
+ xtype: 'checkbox',
+ name: 'showColors',
+ reference: 'showColors',
+ fieldLabel: 'Show Colors:',
+ checked: false,
+ handler: function(checkbox, checked) {
+ Ext.Array.each(me.query('[isFormField]'), function(field) {
+ if (field.fieldGroup !== 'keep') {
+ return;
+ }
+
+ if (checked) {
+ field.setFieldStyle('background-color: ' + COLORS[field.name] + '; ' +
+ 'color: ' + TEXT_COLORS[field.name] + ';');
+ } else {
+ field.setFieldStyle('background-color: white; color: black;');
+ }
+ });
+
+ me.lookupReference('weekTable').useColors = checked;
+ me.lookupReference('pruneList').useColors = checked;
+
+ me.controller.reloadPrune();
+ },
+ },
+ ],
+ },
+ {
+ layout: 'anchor',
+ flex: 1,
+ title: 'Backup Schedule',
+ items: scheduleItems,
+ },
+ ],
+ },
+ {
+ xtype: 'panel',
+ layout: 'hbox',
+ flex: 1,
+ items: [
+ {
+ layout: 'anchor',
+ title: 'Prune Options',
+ items: me.keepItems,
+ flex: 1,
+ },
+ {
+ layout: 'fit',
+ title: 'Backups',
+ xtype: 'prunesimulatorPruneList',
+ store: me.pruneStore,
+ reference: 'pruneList',
+ height: '100%',
+ flex: 1,
+ },
+ ],
+ },
+ {
+ layout: 'anchor',
+ title: 'Calendar',
+ autoScroll: true,
+ flex: 2,
+ xtype: 'prunesimulatorWeekTable',
+ reference: 'weekTable',
+ store: me.pruneStore,
+ bind: {
+ hidden: '{calendarHidden}',
+ },
+ },
+ ];
+
+ me.callParent();
+ },
+ });
+
+ Ext.create('Ext.container.Viewport', {
+ layout: 'border',
+ renderTo: Ext.getBody(),
+ items: [
+ {
+ xtype: 'prunesimulatorPanel',
+ title: 'PBS Prune Simulator',
+ region: 'west',
+ layout: {
+ type: 'vbox',
+ align: 'stretch',
+ pack: 'start',
+ },
+ width: 1080,
+ },
+ {
+ xtype: 'prunesimulatorDocumentation',
+ title: 'Usage',
+ margins: '5 0 0 0',
+ region: 'center',
+ },
+ ],
+ });
+});
+