www/manager/Utils.js

   1 Ext.ns('PVE');
   2
   3 // avoid errors when running without development tools
   4 if (!Ext.isDefined(Ext.global.console)) {
   5     var console = {
   6         dir: function() {},
   7         log: function() {}
   8     };
   9 }
  10 console.log("Starting PVE Manager");
  11
  12 Ext.Ajax.defaultHeaders = {
  13     'Accept': 'application/json'
  14 };
  15
  16 // do not send '_dc' parameter
  17 Ext.Ajax.disableCaching = false;
  18
  19 Ext.Ajax.on('beforerequest', function(conn, options) {
  20     if (PVE.CSRFPreventionToken) {
  21         if (!options.headers) {
  22             options.headers = {};
  23         }
  24         options.headers.CSRFPreventionToken = PVE.CSRFPreventionToken;
  25     }
  26 });
  27
  28 // custom Vtypes
  29 Ext.apply(Ext.form.field.VTypes, {
  30     IPAddress:  function(v) {
  31         return (/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/).test(v);
  32     },
  33     IPAddressText:  gettext('Example') + ': 192.168.1.1',
  34     IPAddressMask: /[\d\.]/i,
  35
  36     MacAddress: function(v) {
  37         return (/^([a-fA-F0-9]{2}:){5}[a-fA-F0-9]{2}$/).test(v);
  38     },
  39     MacAddressMask: /[a-fA-F0-9:]/,
  40     MacAddressText: gettext('Example') + ': 01:23:45:67:89:ab',
  41
  42     BridgeName: function(v) {
  43         return (/^vmbr\d{1,4}$/).test(v);
  44     },
  45     BridgeNameText: gettext('Format') + ': vmbr<b>N</b>, where 0 <= <b>N</b> <= 9999',
  46
  47     BondName: function(v) {
  48         return (/^bond\d{1,4}$/).test(v);
  49     },
  50     BondNameText: gettext('Format') + ': bond<b>N</b>, where 0 <= <b>N</b> <= 9999',
  51
  52     QemuStartDate: function(v) {
  53         return (/^(now|\d{4}-\d{1,2}-\d{1,2}(T\d{1,2}:\d{1,2}:\d{1,2})?)$/).test(v);
  54     },
  55     QemuStartDateText: gettext('Format') + ': "now" or "2006-06-17T16:01:21" or "2006-06-17"',
  56
  57     StorageId:  function(v) {
  58         return (/^[a-z][a-z0-9\-\_\.]*[a-z0-9]$/i).test(v);
  59     },
  60     StorageIdText: gettext("Allowed characters") + ": 'a-z', '0-9', '-', '_', '.'",
  61
  62     HttpProxy:  function(v) {
  63         return (/^http:\/\/.*$/).test(v);
  64     },
  65     HttpProxyText: gettext('Example') + ": http://username:password&#64;host:port/",
  66
  67     DnsName: function(v) {
  68         return (/^(([a-zA-Z0-9]([a-zA-Z0-9\-]*[a-zA-Z0-9])?)\.)*([A-Za-z0-9]([A-Za-z0-9\-]*[A-Za-z0-9])?)$/).test(v);
  69     },
  70     DnsNameText: gettext('This is not a valid DNS name')
  71 });
  72
  73 // we dont want that a displayfield set the form dirty flag!
  74 Ext.override(Ext.form.field.Display, {
  75     isDirty: function() { return false; }
  76 });
  77
  78 // hack: ExtJS does not display the correct value if we
  79 // call setValue while the store is loading, so we need
  80 // to call it again after loading
  81 Ext.override(Ext.form.field.ComboBox, {
  82     onLoad: function() {
  83         this.setValue(this.value, false);
  84         this.callOverridden(arguments);
  85     }
  86 });
  87
  88 Ext.define('PVE.Utils', { statics: {
  89
  90     // this class only contains static functions
  91
  92     log_severity_hash: {
  93         0: "panic",
  94         1: "alert",
  95         2: "critical",
  96         3: "error",
  97         4: "warning",
  98         5: "notice",
  99         6: "info",
 100         7: "debug"
 101     },
 102
 103     support_level_hash: {
 104         'c': gettext('Community'),
 105         'b': gettext('Basic'),
 106         's': gettext('Standard'),
 107         'p': gettext('Premium')
 108     },
 109
 110     noSubKeyHtml: 'You do not have a valid subscription for this server. Please visit <a target="_blank" href="http://www.proxmox.com/products/proxmox-ve/subscription-service-plans">www.proxmox.com</a> to get a list of available options.',
 111
 112     kvm_ostypes: {
 113         other: gettext('Other OS types'),
 114         wxp: 'Microsoft Windows XP/2003',
 115         w2k: 'Microsoft Windows 2000',
 116         w2k8: 'Microsoft Windows Vista/2008',
 117         win7: 'Microsoft Windows 7/2008r2',
 118         win8: 'Microsoft Windows 8/2012',
 119         l24: 'Linux 2.4 Kernel',
 120         l26: 'Linux 3.X/2.6 Kernel',
 121         solaris: 'Solaris Kernel'
 122     },
 123
 124     render_kvm_ostype: function (value) {
 125         if (!value) {
 126             return gettext('Other OS types');
 127         }
 128         var text = PVE.Utils.kvm_ostypes[value];
 129         if (text) {
 130             return text + ' (' + value + ')';
 131         }
 132         return value;
 133     },
 134
 135     render_scsihw: function(value) {
 136         if (!value) {
 137             return PVE.Utils.defaultText + ' (lsi)';
 138         } else if (value === 'lsi') {
 139             return 'LSI 53C895A';
 140         } else if (value === 'megasas') {
 141             return 'MegaRAID SAS 8708EM2';
 142         } else if (value === 'virtio-scsi-pci') {
 143             return 'VIRTIO';
 144         } else {
 145             return value;
 146         }
 147     },
 148
 149     // fixme: auto-generate this
 150     // for now, please keep in sync with PVE::Tools::kvmkeymaps
 151     kvm_keymaps: {
 152         //ar: 'Arabic',
 153         da: 'Danish',
 154         de: 'German',
 155         'de-ch': 'German (Swiss)',
 156         'en-gb': 'English (UK)',
 157         'en-us': 'English (USA',
 158         es: 'Spanish',
 159         //et: 'Estonia',
 160         fi: 'Finnish',
 161         //fo: 'Faroe Islands',
 162         fr: 'French',
 163         'fr-be': 'French (Belgium)',
 164         'fr-ca': 'French (Canada)',
 165         'fr-ch': 'French (Swiss)',
 166         //hr: 'Croatia',
 167         hu: 'Hungarian',
 168         is: 'Icelandic',
 169         it: 'Italian',
 170         ja: 'Japanese',
 171         lt: 'Lithuanian',
 172         //lv: 'Latvian',
 173         mk: 'Macedonian',
 174         nl: 'Dutch',
 175         //'nl-be': 'Dutch (Belgium)',
 176         no: 'Norwegian',
 177         pl: 'Polish',
 178         pt: 'Portuguese',
 179         'pt-br': 'Portuguese (Brazil)',
 180         //ru: 'Russian',
 181         sl: 'Slovenian',
 182         sv: 'Swedish',
 183         //th: 'Thai',
 184         tr: 'Turkish'
 185     },
 186
 187     kvm_vga_drivers: {
 188         std: gettext('Standard VGA'),
 189         vmware: gettext('VMWare compatible'),
 190         cirrus: 'Cirrus Logic GD5446',
 191         qxl: 'SPICE',
 192         serial0: gettext('Serial terminal') + ' 0',
 193         serial1: gettext('Serial terminal') + ' 1',
 194         serial2: gettext('Serial terminal') + ' 2',
 195         serial3: gettext('Serial terminal') + ' 3'
 196     },
 197
 198     render_kvm_language: function (value) {
 199         if (!value) {
 200             return PVE.Utils.defaultText;
 201         }
 202         var text = PVE.Utils.kvm_keymaps[value];
 203         if (text) {
 204             return text + ' (' + value + ')';
 205         }
 206         return value;
 207     },
 208
 209     kvm_keymap_array: function() {
 210         var data = [['', PVE.Utils.render_kvm_language('')]];
 211         Ext.Object.each(PVE.Utils.kvm_keymaps, function(key, value) {
 212             data.push([key, PVE.Utils.render_kvm_language(value)]);
 213         });
 214
 215         return data;
 216     },
 217
 218     language_map: {
 219         zh_CN: 'Chinese',
 220         ca: 'Catalan',
 221         ja: 'Japanese',
 222         en: 'English',
 223         da: 'Danish',
 224         de: 'German',
 225         es: 'Spanish',
 226         fr: 'French',
 227         it: 'Italian',
 228         nb: 'Norwegian (Bokmal)',
 229         nn: 'Norwegian (Nynorsk)',
 230         ru: 'Russian',
 231         sl: 'Slovenian',
 232         sv: 'Swedish',
 233         pl: 'Polish',
 234         pt_BR: 'Portuguese (Brazil)',
 235         tr: 'Turkish'
 236     },
 237
 238     render_language: function (value) {
 239         if (!value) {
 240             return PVE.Utils.defaultText + ' (English)';
 241         }
 242         var text = PVE.Utils.language_map[value];
 243         if (text) {
 244             return text + ' (' + value + ')';
 245         }
 246         return value;
 247     },
 248
 249     language_array: function() {
 250         var data = [['', PVE.Utils.render_language('')]];
 251         Ext.Object.each(PVE.Utils.language_map, function(key, value) {
 252             data.push([key, PVE.Utils.render_language(value)]);
 253         });
 254
 255         return data;
 256     },
 257
 258     render_kvm_vga_driver: function (value) {
 259         if (!value) {
 260             return PVE.Utils.defaultText;
 261         }
 262         var text = PVE.Utils.kvm_vga_drivers[value];
 263         if (text) {
 264             return text + ' (' + value + ')';
 265         }
 266         return value;
 267     },
 268
 269     kvm_vga_driver_array: function() {
 270         var data = [['', PVE.Utils.render_kvm_vga_driver('')]];
 271         Ext.Object.each(PVE.Utils.kvm_vga_drivers, function(key, value) {
 272             data.push([key, PVE.Utils.render_kvm_vga_driver(value)]);
 273         });
 274
 275         return data;
 276     },
 277
 278     render_kvm_startup: function(value) {
 279         var startup = PVE.Parser.parseStartup(value);
 280
 281         var res = 'order=';
 282         if (startup.order === undefined) {
 283             res += 'any';
 284         } else {
 285             res += startup.order;
 286         }
 287         if (startup.up !== undefined) {
 288             res += ',up=' + startup.up;
 289         }
 290         if (startup.down !== undefined) {
 291             res += ',down=' + startup.down;
 292         }
 293
 294         return res;
 295     },
 296
 297     authOK: function() {
 298         return Ext.util.Cookies.get('PVEAuthCookie');
 299     },
 300
 301     authClear: function() {
 302         Ext.util.Cookies.clear("PVEAuthCookie");
 303     },
 304
 305     // fixme: remove - not needed?
 306     gridLineHeigh: function() {
 307         return 21;
 308
 309         //if (Ext.isGecko)
 310         //return 23;
 311         //return 21;
 312     },
 313
 314     extractRequestError: function(result, verbose) {
 315         var msg = gettext('Successful');
 316
 317         if (!result.success) {
 318             msg = gettext("Unknown error");
 319             if (result.message) {
 320                 msg = result.message;
 321                 if (result.status) {
 322                     msg += ' (' + result.status + ')';
 323                 }
 324             }
 325             if (verbose && Ext.isObject(result.errors)) {
 326                 msg += "<br>";
 327                 Ext.Object.each(result.errors, function(prop, desc) {
 328                     msg += "<br><b>" + Ext.htmlEncode(prop) + "</b>: " +
 329                         Ext.htmlEncode(desc);
 330                 });
 331             }
 332         }
 333
 334         return msg;
 335     },
 336
 337     extractFormActionError: function(action) {
 338         var msg;
 339         switch (action.failureType) {
 340         case Ext.form.action.Action.CLIENT_INVALID:
 341             msg = gettext('Form fields may not be submitted with invalid values');
 342             break;
 343         case Ext.form.action.Action.CONNECT_FAILURE:
 344             msg = gettext('Connection error');
 345             var resp = action.response;
 346             if (resp.status && resp.statusText) {
 347                 msg += " " + resp.status + ": " + resp.statusText;
 348             }
 349             break;
 350         case Ext.form.action.Action.LOAD_FAILURE:
 351         case Ext.form.action.Action.SERVER_INVALID:
 352             msg = PVE.Utils.extractRequestError(action.result, true);
 353             break;
 354         }
 355         return msg;
 356     },
 357
 358     // Ext.Ajax.request
 359     API2Request: function(reqOpts) {
 360
 361         var newopts = Ext.apply({
 362             waitMsg: gettext('Please wait...')
 363         }, reqOpts);
 364
 365         if (!newopts.url.match(/^\/api2/)) {
 366             newopts.url = '/api2/extjs' + newopts.url;
 367         }
 368         delete newopts.callback;
 369
 370         var createWrapper = function(successFn, callbackFn, failureFn) {
 371             Ext.apply(newopts, {
 372                 success: function(response, options) {
 373                     if (options.waitMsgTarget) {
 374                         options.waitMsgTarget.setLoading(false);
 375                     }
 376                     var result = Ext.decode(response.responseText);
 377                     response.result = result;
 378                     if (!result.success) {
 379                         response.htmlStatus = PVE.Utils.extractRequestError(result, true);
 380                         Ext.callback(callbackFn, options.scope, [options, false, response]);
 381                         Ext.callback(failureFn, options.scope, [response, options]);
 382                         return;
 383                     }
 384                     Ext.callback(callbackFn, options.scope, [options, true, response]);
 385                     Ext.callback(successFn, options.scope, [response, options]);
 386                 },
 387                 failure: function(response, options) {
 388                     if (options.waitMsgTarget) {
 389                         options.waitMsgTarget.setLoading(false);
 390                     }
 391                     response.result = {};
 392                     try {
 393                         response.result = Ext.decode(response.responseText);
 394                     } catch(e) {}
 395                     var msg = gettext('Connection error') + ' - server offline?';
 396                     if (response.aborted) {
 397                         msg = gettext('Connection error') + ' - aborted.';
 398                     } else if (response.timedout) {
 399                         msg = gettext('Connection error') + ' - Timeout.';
 400                     } else if (response.status && response.statusText) {
 401                         msg = gettext('Connection error') + ' ' + response.status + ': ' + response.statusText;
 402                     }
 403                     response.htmlStatus = msg;
 404                     Ext.callback(callbackFn, options.scope, [options, false, response]);
 405                     Ext.callback(failureFn, options.scope, [response, options]);
 406                 }
 407             });
 408         };
 409
 410         createWrapper(reqOpts.success, reqOpts.callback, reqOpts.failure);
 411
 412         var target = newopts.waitMsgTarget;
 413         if (target) {
 414             // Note: ExtJS bug - this does not work when component is not rendered
 415             target.setLoading(newopts.waitMsg);
 416         }
 417         Ext.Ajax.request(newopts);
 418     },
 419
 420     assemble_field_data: function(values, data) {
 421         if (Ext.isObject(data)) {
 422             Ext.Object.each(data, function(name, val) {
 423                 if (values.hasOwnProperty(name)) {
 424                     var bucket = values[name];
 425                     if (!Ext.isArray(bucket)) {
 426                         bucket = values[name] = [bucket];
 427                     }
 428                     if (Ext.isArray(val)) {
 429                         values[name] = bucket.concat(val);
 430                     } else {
 431                         bucket.push(val);
 432                     }
 433                 } else {
 434                     values[name] = val;
 435                 }
 436             });
 437         }
 438     },
 439
 440     checked_command: function(orig_cmd) {
 441         PVE.Utils.API2Request({
 442             url: '/nodes/localhost/subscription',
 443             method: 'GET',
 444             //waitMsgTarget: me,
 445             failure: function(response, opts) {
 446                 Ext.Msg.alert(gettext('Error'), response.htmlStatus);
 447             },
 448             success: function(response, opts) {
 449                 var data = response.result.data;
 450
 451                 if (data.status !== 'Active') {
 452                     Ext.Msg.show({
 453                         title: gettext('No valid subscription'),
 454                         icon: Ext.Msg.WARNING,
 455                         msg: PVE.Utils.noSubKeyHtml,
 456                         buttons: Ext.Msg.OK,
 457                         callback: function(btn) {
 458                             if (btn !== 'ok') {
 459                                 return;
 460                             }
 461                             orig_cmd();
 462                         }
 463                     });
 464                 } else {
 465                     orig_cmd();
 466                 }
 467             }
 468         });
 469     },
 470
 471     task_desc_table: {
 472         vncproxy: [ 'VM/CT', gettext('Console') ],
 473         spiceproxy: [ 'VM/CT', gettext('Console') + ' (Spice)' ],
 474         vncshell: [ '', gettext('Shell') ],
 475         qmsnapshot: [ 'VM', gettext('Snapshot') ],
 476         qmrollback: [ 'VM', gettext('Rollback') ],
 477         qmdelsnapshot: [ 'VM', gettext('Delete Snapshot') ],
 478         qmcreate: [ 'VM', gettext('Create') ],
 479         qmrestore: [ 'VM', gettext('Restore') ],
 480         qmdestroy: [ 'VM', gettext('Destroy') ],
 481         qmigrate: [ 'VM', gettext('Migrate') ],
 482         qmclone: [ 'VM', gettext('Clone') ],
 483         qmmove: [ 'VM', gettext('Move disk') ],
 484         qmtemplate: [ 'VM', gettext('Convert to template') ],
 485         qmstart: [ 'VM', gettext('Start') ],
 486         qmstop: [ 'VM', gettext('Stop') ],
 487         qmreset: [ 'VM', gettext('Reset') ],
 488         qmshutdown: [ 'VM', gettext('Shutdown') ],
 489         qmsuspend: [ 'VM', gettext('Suspend') ],
 490         qmresume: [ 'VM', gettext('Resume') ],
 491         qmconfig: [ 'VM', gettext('Configure') ],
 492         vzcreate: ['CT', gettext('Create') ],
 493         vzrestore: ['CT', gettext('Restore') ],
 494         vzdestroy: ['CT', gettext('Destroy') ],
 495         vzmigrate: [ 'CT', gettext('Migrate') ],
 496         vzstart: ['CT', gettext('Start') ],
 497         vzstop: ['CT', gettext('Stop') ],
 498         vzmount: ['CT', gettext('Mount') ],
 499         vzumount: ['CT', gettext('Unmount') ],
 500         vzshutdown: ['CT', gettext('Shutdown') ],
 501         hamigrate: [ 'HA', gettext('Migrate') ],
 502         hastart: [ 'HA', gettext('Start') ],
 503         hastop: [ 'HA', gettext('Stop') ],
 504         srvstart: ['SRV', gettext('Start') ],
 505         srvstop: ['SRV', gettext('Stop') ],
 506         srvrestart: ['SRV', gettext('Restart') ],
 507         srvreload: ['SRV', gettext('Reload') ],
 508         imgcopy: ['', gettext('Copy data') ],
 509         imgdel: ['', gettext('Erase data') ],
 510         download: ['', gettext('Download') ],
 511         vzdump: ['', gettext('Backup') ],
 512         aptupdate: ['', gettext('Update package database') ],
 513         startall: [ '', gettext('Start all VMs and Containers') ],
 514         stopall: [ '', gettext('Stop all VMs and Containers') ]
 515     },
 516
 517     format_task_description: function(type, id) {
 518         var farray = PVE.Utils.task_desc_table[type];
 519         if (!farray) {
 520             return type;
 521         }
 522         var prefix = farray[0];
 523         var text = farray[1];
 524         if (prefix) {
 525             return prefix + ' ' + id + ' - ' + text;
 526         }
 527         return text;
 528     },
 529
 530     parse_task_upid: function(upid) {
 531         var task = {};
 532
 533         var res = upid.match(/^UPID:(\S+):([0-9A-Fa-f]{8}):([0-9A-Fa-f]{8}):([0-9A-Fa-f]{8}):([^:\s]+):([^:\s]*):([^:\s]+):$/);
 534         if (!res) {
 535             throw "unable to parse upid '" + upid + "'";
 536         }
 537         task.node = res[1];
 538         task.pid = parseInt(res[2], 16);
 539         task.pstart = parseInt(res[3], 16);
 540         task.starttime = parseInt(res[4], 16);
 541         task.type = res[5];
 542         task.id = res[6];
 543         task.user = res[7];
 544
 545         task.desc = PVE.Utils.format_task_description(task.type, task.id);
 546
 547         return task;
 548     },
 549
 550     format_size: function(size) {
 551         /*jslint confusion: true */
 552
 553         if (size < 1024) {
 554             return size;
 555         }
 556
 557         var kb = size / 1024;
 558
 559         if (kb < 1024) {
 560             return kb.toFixed(0) + "KB";
 561         }
 562
 563         var mb = size / (1024*1024);
 564
 565         if (mb < 1024) {
 566             return mb.toFixed(0) + "MB";
 567         }
 568
 569         var gb = mb / 1024;
 570
 571         if (gb < 1024) {
 572             return gb.toFixed(2) + "GB";
 573         }
 574
 575         var tb =  gb / 1024;
 576
 577         return tb.toFixed(2) + "TB";
 578
 579     },
 580
 581     format_html_bar: function(per, text) {
 582
 583         return "<div class='pve-bar-wrap'>" + text + "<div class='pve-bar-border'>" +
 584             "<div class='pve-bar-inner' style='width:" + per + "%;'></div>" +
 585             "</div></div>";
 586
 587     },
 588
 589     format_cpu_bar: function(per1, per2, text) {
 590
 591         return "<div class='pve-bar-border'>" +
 592             "<div class='pve-bar-inner' style='width:" + per1 + "%;'></div>" +
 593             "<div class='pve-bar-inner2' style='width:" + per2 + "%;'></div>" +
 594             "<div class='pve-bar-text'>" + text + "</div>" +
 595             "</div>";
 596     },
 597
 598     format_large_bar: function(per, text) {
 599
 600         if (!text) {
 601             text = per.toFixed(1) + "%";
 602         }
 603
 604         return "<div class='pve-largebar-border'>" +
 605             "<div class='pve-largebar-inner' style='width:" + per + "%;'></div>" +
 606             "<div class='pve-largebar-text'>" + text + "</div>" +
 607             "</div>";
 608     },
 609
 610     format_duration_long: function(ut) {
 611
 612         var days = Math.floor(ut / 86400);
 613         ut -= days*86400;
 614         var hours = Math.floor(ut / 3600);
 615         ut -= hours*3600;
 616         var mins = Math.floor(ut / 60);
 617         ut -= mins*60;
 618
 619         var hours_str = '00' + hours.toString();
 620         hours_str = hours_str.substr(hours_str.length - 2);
 621         var mins_str = "00" + mins.toString();
 622         mins_str = mins_str.substr(mins_str.length - 2);
 623         var ut_str = "00" + ut.toString();
 624         ut_str = ut_str.substr(ut_str.length - 2);
 625
 626         if (days) {
 627             var ds = days > 1 ? PVE.Utils.daysText : PVE.Utils.dayText;
 628             return days.toString() + ' ' + ds + ' ' +
 629                 hours_str + ':' + mins_str + ':' + ut_str;
 630         } else {
 631             return hours_str + ':' + mins_str + ':' + ut_str;
 632         }
 633     },
 634
 635     format_duration_short: function(ut) {
 636
 637         if (ut < 60) {
 638             return ut.toString() + 's';
 639         }
 640
 641         if (ut < 3600) {
 642             var mins = ut / 60;
 643             return mins.toFixed(0) + 'm';
 644         }
 645
 646         if (ut < 86400) {
 647             var hours = ut / 3600;
 648             return hours.toFixed(0) + 'h';
 649         }
 650
 651         var days = ut / 86400;
 652         return days.toFixed(0) + 'd';
 653     },
 654
 655     yesText: gettext('Yes'),
 656     noText: gettext('No'),
 657     errorText: gettext('Error'),
 658     unknownText: gettext('Unknown'),
 659     defaultText: gettext('Default'),
 660     daysText: gettext('days'),
 661     dayText: gettext('day'),
 662     runningText: gettext('running'),
 663     stoppedText: gettext('stopped'),
 664     neverText: gettext('never'),
 665     totalText: gettext('Total'),
 666     usedText: gettext('Used'),
 667
 668     format_expire: function(date) {
 669         if (!date) {
 670             return PVE.Utils.neverText;
 671         }
 672         return Ext.Date.format(date, "Y-m-d");
 673     },
 674
 675     format_storage_type: function(value) {
 676         if (value === 'dir') {
 677             return 'Directory';
 678         } else if (value === 'nfs') {
 679             return 'NFS';
 680         } else if (value === 'glusterfs') {
 681             return 'GlusterFS';
 682         } else if (value === 'lvm') {
 683             return 'LVM';
 684         } else if (value === 'iscsi') {
 685             return 'iSCSI';
 686         } else if (value === 'rbd') {
 687             return 'RBD';
 688         } else if (value === 'sheepdog') {
 689             return 'Sheepdog';
 690         } else if (value === 'nexenta') {
 691             return 'Nexenta';
 692         } else if (value === 'iscsidirect') {
 693             return 'iSCSIDirect';
 694         } else {
 695             return PVE.Utils.unknownText;
 696         }
 697     },
 698
 699     format_boolean_with_default: function(value) {
 700         if (Ext.isDefined(value) && value !== '') {
 701             return value ? PVE.Utils.yesText : PVE.Utils.noText;
 702         }
 703         return PVE.Utils.defaultText;
 704     },
 705
 706     format_boolean: function(value) {
 707         return value ? PVE.Utils.yesText : PVE.Utils.noText;
 708     },
 709
 710     format_neg_boolean: function(value) {
 711         return !value ? PVE.Utils.yesText : PVE.Utils.noText;
 712     },
 713
 714     format_content_types: function(value) {
 715         var cta = [];
 716
 717         Ext.each(value.split(',').sort(), function(ct) {
 718             if (ct === 'images') {
 719                 cta.push('Images');
 720             } else if (ct === 'backup') {
 721                 cta.push('Backups');
 722             } else if (ct === 'vztmpl') {
 723                 cta.push('Templates');
 724             } else if (ct === 'iso') {
 725                 cta.push('ISO');
 726             } else if (ct === 'rootdir') {
 727                 cta.push('Containers');
 728             }
 729         });
 730
 731         return cta.join(', ');
 732     },
 733
 734     render_storage_content: function(value, metaData, record) {
 735         var data = record.data;
 736         if (Ext.isNumber(data.channel) &&
 737             Ext.isNumber(data.id) &&
 738             Ext.isNumber(data.lun)) {
 739             return "CH " +
 740                 Ext.String.leftPad(data.channel,2, '0') +
 741                 " ID " + data.id + " LUN " + data.lun;
 742         }
 743         return data.volid.replace(/^.*:(.*\/)?/,'');
 744     },
 745
 746     render_serverity: function (value) {
 747         return PVE.Utils.log_severity_hash[value] || value;
 748     },
 749
 750     render_cpu: function(value, metaData, record, rowIndex, colIndex, store) {
 751
 752         if (!(record.data.uptime && Ext.isNumeric(value))) {
 753             return '';
 754         }
 755
 756         var maxcpu = record.data.maxcpu || 1;
 757
 758         if (!Ext.isNumeric(maxcpu) && (maxcpu >= 1)) {
 759             return '';
 760         }
 761
 762         var per = value * 100;
 763
 764         return per.toFixed(1) + '% of ' + maxcpu.toString() + (maxcpu > 1 ? 'CPUs' : 'CPU');
 765     },
 766
 767     render_size: function(value, metaData, record, rowIndex, colIndex, store) {
 768         /*jslint confusion: true */
 769
 770         if (!Ext.isNumeric(value)) {
 771             return '';
 772         }
 773
 774         return PVE.Utils.format_size(value);
 775     },
 776
 777     render_timestamp: function(value, metaData, record, rowIndex, colIndex, store) {
 778         var servertime = new Date(value * 1000);
 779         return Ext.Date.format(servertime, 'Y-m-d H:i:s');
 780     },
 781
 782     render_mem_usage: function(value, metaData, record, rowIndex, colIndex, store) {
 783
 784         var mem = value;
 785         var maxmem = record.data.maxmem;
 786
 787         if (!record.data.uptime) {
 788             return '';
 789         }
 790
 791         if (!(Ext.isNumeric(mem) && maxmem)) {
 792             return '';
 793         }
 794
 795         var per = (mem * 100) / maxmem;
 796
 797         return per.toFixed(1) + '%';
 798     },
 799
 800     render_disk_usage: function(value, metaData, record, rowIndex, colIndex, store) {
 801
 802         var disk = value;
 803         var maxdisk = record.data.maxdisk;
 804
 805         if (!(Ext.isNumeric(disk) && maxdisk)) {
 806             return '';
 807         }
 808
 809         var per = (disk * 100) / maxdisk;
 810
 811         return per.toFixed(1) + '%';
 812     },
 813
 814     render_resource_type: function(value, metaData, record, rowIndex, colIndex, store) {
 815
 816         var cls = 'pve-itype-icon-' + value;
 817
 818         if (record.data.running) {
 819             metaData.tdCls = cls + "-running";
 820         } else if (record.data.template) {
 821             metaData.tdCls = cls + "-template";
 822         } else {
 823             metaData.tdCls = cls;
 824         }
 825
 826         return value;
 827     },
 828
 829     render_uptime: function(value, metaData, record, rowIndex, colIndex, store) {
 830
 831         var uptime = value;
 832
 833         if (uptime === undefined) {
 834             return '';
 835         }
 836
 837         if (uptime <= 0) {
 838             return '-';
 839         }
 840
 841         return PVE.Utils.format_duration_long(uptime);
 842     },
 843
 844     render_support_level: function(value, metaData, record) {
 845         return PVE.Utils.support_level_hash[value] || '-';
 846     },
 847
 848     render_upid: function(value, metaData, record) {
 849         var type = record.data.type;
 850         var id = record.data.id;
 851
 852         return PVE.Utils.format_task_description(type, id);
 853     },
 854
 855     dialog_title: function(subject, create, isAdd) {
 856         if (create) {
 857             if (isAdd) {
 858                 return gettext('Add') + ': ' + subject;
 859             } else {
 860                 return gettext('Create') + ': ' + subject;
 861             }
 862         } else {
 863             return gettext('Edit') + ': ' + subject;
 864         }
 865     },
 866
 867     openConoleWindow: function(vmtype, vmid, nodename, vmname) {
 868         var url = Ext.urlEncode({
 869             console: vmtype, // kvm, openvz or shell
 870             vmid: vmid,
 871             vmname: vmname,
 872             node: nodename
 873         });
 874         var nw = window.open("?" + url, '_blank',
 875                              "innerWidth=745,innerheight=427");
 876         nw.focus();
 877     },
 878
 879     // comp.setLoading() is buggy in ExtJS 4.0.7, so we
 880     // use el.mask() instead
 881     setErrorMask: function(comp, msg) {
 882         var el = comp.el;
 883         if (!el) {
 884             return;
 885         }
 886         if (!msg) {
 887             el.unmask();
 888         } else {
 889             if (msg === true) {
 890                 el.mask(gettext("Loading..."));
 891             } else {
 892                 el.mask(msg);
 893             }
 894         }
 895     },
 896
 897     monStoreErrors: function(me, store) {
 898         me.mon(store, 'beforeload', function(s, operation, eOpts) {
 899             if (!me.loadCount) {
 900                 me.loadCount = 0; // make sure it is numeric
 901                 PVE.Utils.setErrorMask(me, true);
 902             }
 903         });
 904
 905         // only works with 'pve' proxy
 906         me.mon(store.proxy, 'afterload', function(proxy, request, success) {
 907             me.loadCount++;
 908
 909             if (success) {
 910                 PVE.Utils.setErrorMask(me, false);
 911                 return;
 912             }
 913
 914             var msg;
 915             var operation = request.operation;
 916             var error = operation.getError();
 917             if (error.statusText) {
 918                 msg = error.statusText + ' (' + error.status + ')';
 919             } else {
 920                 msg = gettext('Connection error');
 921             }
 922             PVE.Utils.setErrorMask(me, msg);
 923         });
 924     }
 925
 926 }});
 927