www/manager6/Utils.js

   1 Ext.ns('PVE');
   2
   3 // avoid errors related to Accessible Rich Internet Applications
   4 // (access for people with disabilities)
   5 // TODO reenable after all components are upgraded
   6 Ext.enableAria = false;
   7 Ext.enableAriaButtons = false;
   8 Ext.enableAriaPanels = false;
   9
  10 // avoid errors when running without development tools
  11 if (!Ext.isDefined(Ext.global.console)) {
  12     var console = {
  13         dir: function() {},
  14         log: function() {}
  15     };
  16 }
  17 console.log("Starting PVE Manager");
  18
  19 Ext.Ajax.defaultHeaders = {
  20     'Accept': 'application/json'
  21 };
  22
  23 Ext.Ajax.on('beforerequest', function(conn, options) {
  24     if (PVE.CSRFPreventionToken) {
  25         if (!options.headers) {
  26             options.headers = {};
  27         }
  28         options.headers.CSRFPreventionToken = PVE.CSRFPreventionToken;
  29     }
  30 });
  31
  32 Ext.define('PVE.Utils', { utilities: {
  33
  34     // this singleton contains miscellaneous utilities
  35
  36     toolkit: undefined, // (extjs|touch), set inside Toolkit.js
  37
  38     bus_match: /^(ide|sata|virtio|scsi)\d+$/,
  39
  40     log_severity_hash: {
  41         0: "panic",
  42         1: "alert",
  43         2: "critical",
  44         3: "error",
  45         4: "warning",
  46         5: "notice",
  47         6: "info",
  48         7: "debug"
  49     },
  50
  51     support_level_hash: {
  52         'c': gettext('Community'),
  53         'b': gettext('Basic'),
  54         's': gettext('Standard'),
  55         'p': gettext('Premium')
  56     },
  57
  58     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.',
  59
  60     kvm_ostypes: {
  61         other: gettext('Other OS types'),
  62         wxp: 'Microsoft Windows XP/2003',
  63         w2k: 'Microsoft Windows 2000',
  64         w2k8: 'Microsoft Windows Vista/2008',
  65         win7: 'Microsoft Windows 7/2008r2',
  66         win8: 'Microsoft Windows 8.x/2012/2012r2',
  67         win10: 'Microsoft Windows 10/2016',
  68         l24: 'Linux 2.4 Kernel',
  69         l26: 'Linux 4.X/3.X/2.6 Kernel',
  70         solaris: 'Solaris Kernel'
  71     },
  72
  73     get_health_icon: function(state, circle) {
  74         if (circle === undefined) {
  75             circle = false;
  76         }
  77
  78         if (state === undefined) {
  79             state = 'uknown';
  80         }
  81
  82         var icon = 'faded fa-question';
  83         switch(state) {
  84             case 'good':
  85                 icon = 'good fa-check';
  86                 break;
  87             case 'warning':
  88                 icon = 'warning fa-exclamation';
  89                 break;
  90             case 'critical':
  91                 icon = 'critical fa-times';
  92                 break;
  93             default: break;
  94         }
  95
  96         if (circle) {
  97             icon += '-circle';
  98         }
  99
 100         return icon;
 101     },
 102
 103     map_ceph_health: {
 104         'HEALTH_OK':'good',
 105         'HEALTH_WARN':'warning',
 106         'HEALTH_ERR':'critical'
 107     },
 108
 109     render_ceph_health: function(record) {
 110         var state = {
 111             iconCls: PVE.Utils.get_health_icon(),
 112             text: ''
 113         };
 114
 115         if (!record || !record.data) {
 116             return state;
 117         }
 118
 119         var health = PVE.Utils.map_ceph_health[record.data.health.overall_status];
 120
 121         state.iconCls = PVE.Utils.get_health_icon(health, true);
 122         state.text = record.data.health.overall_status;
 123
 124         return state;
 125     },
 126
 127     render_kvm_ostype: function (value) {
 128         if (!value) {
 129             return gettext('Other OS types');
 130         }
 131         var text = PVE.Utils.kvm_ostypes[value];
 132         if (text) {
 133             return text;
 134         }
 135         return value;
 136     },
 137
 138     render_hotplug_features: function (value) {
 139         var fa = [];
 140
 141         if (!value || (value === '0')) {
 142             return gettext('Disabled');
 143         }
 144
 145         if (value === '1') {
 146             value = 'disk,network,usb';
 147         }
 148
 149         Ext.each(value.split(','), function(el) {
 150             if (el === 'disk') {
 151                 fa.push(gettext('Disk'));
 152             } else if (el === 'network') {
 153                 fa.push(gettext('Network'));
 154             } else if (el === 'usb') {
 155                 fa.push('USB');
 156             } else if (el === 'memory') {
 157                 fa.push(gettext('Memory'));
 158             } else if (el === 'cpu') {
 159                 fa.push(gettext('CPU'));
 160             } else {
 161                 fa.push(el);
 162             }
 163         });
 164
 165         return fa.join(', ');
 166     },
 167
 168     network_iface_types: {
 169         eth: gettext("Network Device"),
 170         bridge: 'Linux Bridge',
 171         bond: 'Linux Bond',
 172         OVSBridge: 'OVS Bridge',
 173         OVSBond: 'OVS Bond',
 174         OVSPort: 'OVS Port',
 175         OVSIntPort: 'OVS IntPort'
 176     },
 177
 178     render_network_iface_type: function(value) {
 179         return PVE.Utils.network_iface_types[value] ||
 180             PVE.Utils.unknownText;
 181     },
 182
 183     render_qemu_bios: function(value) {
 184         if (!value) {
 185             return PVE.Utils.defaultText + ' (SeaBIOS)';
 186         } else if (value === 'seabios') {
 187             return "SeaBIOS";
 188         } else if (value === 'ovmf') {
 189             return "OVMF (UEFI)";
 190         } else {
 191             return value;
 192         }
 193     },
 194
 195     render_scsihw: function(value) {
 196         if (!value) {
 197             return PVE.Utils.defaultText + ' (LSI 53C895A)';
 198         } else if (value === 'lsi') {
 199             return 'LSI 53C895A';
 200         } else if (value === 'lsi53c810') {
 201             return 'LSI 53C810';
 202         } else if (value === 'megasas') {
 203             return 'MegaRAID SAS 8708EM2';
 204         } else if (value === 'virtio-scsi-pci') {
 205             return 'VirtIO SCSI';
 206         } else if (value === 'virtio-scsi-single') {
 207             return 'VirtIO SCSI single';
 208         } else if (value === 'pvscsi') {
 209             return 'VMware PVSCSI';
 210         } else {
 211             return value;
 212         }
 213     },
 214
 215     // fixme: auto-generate this
 216     // for now, please keep in sync with PVE::Tools::kvmkeymaps
 217     kvm_keymaps: {
 218         //ar: 'Arabic',
 219         da: 'Danish',
 220         de: 'German',
 221         'de-ch': 'German (Swiss)',
 222         'en-gb': 'English (UK)',
 223         'en-us': 'English (USA)',
 224         es: 'Spanish',
 225         //et: 'Estonia',
 226         fi: 'Finnish',
 227         //fo: 'Faroe Islands',
 228         fr: 'French',
 229         'fr-be': 'French (Belgium)',
 230         'fr-ca': 'French (Canada)',
 231         'fr-ch': 'French (Swiss)',
 232         //hr: 'Croatia',
 233         hu: 'Hungarian',
 234         is: 'Icelandic',
 235         it: 'Italian',
 236         ja: 'Japanese',
 237         lt: 'Lithuanian',
 238         //lv: 'Latvian',
 239         mk: 'Macedonian',
 240         nl: 'Dutch',
 241         //'nl-be': 'Dutch (Belgium)',
 242         no: 'Norwegian',
 243         pl: 'Polish',
 244         pt: 'Portuguese',
 245         'pt-br': 'Portuguese (Brazil)',
 246         //ru: 'Russian',
 247         sl: 'Slovenian',
 248         sv: 'Swedish',
 249         //th: 'Thai',
 250         tr: 'Turkish'
 251     },
 252
 253     kvm_vga_drivers: {
 254         std: gettext('Standard VGA'),
 255         vmware: gettext('VMware compatible'),
 256         cirrus: 'Cirrus Logic GD5446',
 257         qxl: 'SPICE',
 258         qxl2: 'SPICE dual monitor',
 259         qxl3: 'SPICE three monitors',
 260         qxl4: 'SPICE four monitors',
 261         serial0: gettext('Serial terminal') + ' 0',
 262         serial1: gettext('Serial terminal') + ' 1',
 263         serial2: gettext('Serial terminal') + ' 2',
 264         serial3: gettext('Serial terminal') + ' 3'
 265     },
 266
 267     render_kvm_language: function (value) {
 268         if (!value) {
 269             return PVE.Utils.defaultText;
 270         }
 271         var text = PVE.Utils.kvm_keymaps[value];
 272         if (text) {
 273             return text + ' (' + value + ')';
 274         }
 275         return value;
 276     },
 277
 278     kvm_keymap_array: function() {
 279         var data = [['__default__', PVE.Utils.render_kvm_language('')]];
 280         Ext.Object.each(PVE.Utils.kvm_keymaps, function(key, value) {
 281             data.push([key, PVE.Utils.render_kvm_language(value)]);
 282         });
 283
 284         return data;
 285     },
 286
 287     render_console_viewer: function(value) {
 288         if (!value || value === '__default__') {
 289             return PVE.Utils.defaultText + ' (HTML5)';
 290         } else if (value === 'vv') {
 291             return  'SPICE (remote-viewer)';
 292         } else if (value === 'html5') {
 293             return  'HTML5 (noVNC)';
 294         } else {
 295             return value;
 296         }
 297     },
 298
 299     language_map: {
 300         zh_CN: 'Chinese',
 301         ca: 'Catalan',
 302         da: 'Danish',
 303         en: 'English',
 304         eu: 'Euskera (Basque)',
 305         fr: 'French',
 306         de: 'German',
 307         it: 'Italian',
 308         ja: 'Japanese',
 309         nb: 'Norwegian (Bokmal)',
 310         nn: 'Norwegian (Nynorsk)',
 311         fa: 'Persian (Farsi)',
 312         pl: 'Polish',
 313         pt_BR: 'Portuguese (Brazil)',
 314         ru: 'Russian',
 315         sl: 'Slovenian',
 316         es: 'Spanish',
 317         sv: 'Swedish',
 318         tr: 'Turkish'
 319     },
 320
 321     render_language: function (value) {
 322         if (!value) {
 323             return PVE.Utils.defaultText + ' (English)';
 324         }
 325         var text = PVE.Utils.language_map[value];
 326         if (text) {
 327             return text + ' (' + value + ')';
 328         }
 329         return value;
 330     },
 331
 332     language_array: function() {
 333         var data = [['__default__', PVE.Utils.render_language('')]];
 334         Ext.Object.each(PVE.Utils.language_map, function(key, value) {
 335             data.push([key, PVE.Utils.render_language(value)]);
 336         });
 337
 338         return data;
 339     },
 340
 341     render_kvm_vga_driver: function (value) {
 342         if (!value) {
 343             return PVE.Utils.defaultText;
 344         }
 345         var text = PVE.Utils.kvm_vga_drivers[value];
 346         if (text) {
 347             return text + ' (' + value + ')';
 348         }
 349         return value;
 350     },
 351
 352     kvm_vga_driver_array: function() {
 353         var data = [['__default__', PVE.Utils.render_kvm_vga_driver('')]];
 354         Ext.Object.each(PVE.Utils.kvm_vga_drivers, function(key, value) {
 355             data.push([key, PVE.Utils.render_kvm_vga_driver(value)]);
 356         });
 357
 358         return data;
 359     },
 360
 361     render_kvm_startup: function(value) {
 362         var startup = PVE.Parser.parseStartup(value);
 363
 364         var res = 'order=';
 365         if (startup.order === undefined) {
 366             res += 'any';
 367         } else {
 368             res += startup.order;
 369         }
 370         if (startup.up !== undefined) {
 371             res += ',up=' + startup.up;
 372         }
 373         if (startup.down !== undefined) {
 374             res += ',down=' + startup.down;
 375         }
 376
 377         return res;
 378     },
 379
 380     authOK: function() {
 381         return Ext.util.Cookies.get('PVEAuthCookie');
 382     },
 383
 384     authClear: function() {
 385         Ext.util.Cookies.clear("PVEAuthCookie");
 386     },
 387
 388     // fixme: remove - not needed?
 389     gridLineHeigh: function() {
 390         return 21;
 391
 392         //if (Ext.isGecko)
 393         //return 23;
 394         //return 21;
 395     },
 396
 397     extractRequestError: function(result, verbose) {
 398         var msg = gettext('Successful');
 399
 400         if (!result.success) {
 401             msg = gettext("Unknown error");
 402             if (result.message) {
 403                 msg = result.message;
 404                 if (result.status) {
 405                     msg += ' (' + result.status + ')';
 406                 }
 407             }
 408             if (verbose && Ext.isObject(result.errors)) {
 409                 msg += "<br>";
 410                 Ext.Object.each(result.errors, function(prop, desc) {
 411                     msg += "<br><b>" + Ext.htmlEncode(prop) + "</b>: " +
 412                         Ext.htmlEncode(desc);
 413                 });
 414             }
 415         }
 416
 417         return msg;
 418     },
 419
 420     extractFormActionError: function(action) {
 421         var msg;
 422         switch (action.failureType) {
 423         case Ext.form.action.Action.CLIENT_INVALID:
 424             msg = gettext('Form fields may not be submitted with invalid values');
 425             break;
 426         case Ext.form.action.Action.CONNECT_FAILURE:
 427             msg = gettext('Connection error');
 428             var resp = action.response;
 429             if (resp.status && resp.statusText) {
 430                 msg += " " + resp.status + ": " + resp.statusText;
 431             }
 432             break;
 433         case Ext.form.action.Action.LOAD_FAILURE:
 434         case Ext.form.action.Action.SERVER_INVALID:
 435             msg = PVE.Utils.extractRequestError(action.result, true);
 436             break;
 437         }
 438         return msg;
 439     },
 440
 441     // Ext.Ajax.request
 442     API2Request: function(reqOpts) {
 443
 444         var newopts = Ext.apply({
 445             waitMsg: gettext('Please wait...')
 446         }, reqOpts);
 447
 448         if (!newopts.url.match(/^\/api2/)) {
 449             newopts.url = '/api2/extjs' + newopts.url;
 450         }
 451         delete newopts.callback;
 452
 453         var createWrapper = function(successFn, callbackFn, failureFn) {
 454             Ext.apply(newopts, {
 455                 success: function(response, options) {
 456                     if (options.waitMsgTarget) {
 457                         if (PVE.Utils.toolkit === 'touch') {
 458                             options.waitMsgTarget.setMasked(false);
 459                         } else {
 460                             options.waitMsgTarget.setLoading(false);
 461                         }
 462                     }
 463                     var result = Ext.decode(response.responseText);
 464                     response.result = result;
 465                     if (!result.success) {
 466                         response.htmlStatus = PVE.Utils.extractRequestError(result, true);
 467                         Ext.callback(callbackFn, options.scope, [options, false, response]);
 468                         Ext.callback(failureFn, options.scope, [response, options]);
 469                         return;
 470                     }
 471                     Ext.callback(callbackFn, options.scope, [options, true, response]);
 472                     Ext.callback(successFn, options.scope, [response, options]);
 473                 },
 474                 failure: function(response, options) {
 475                     if (options.waitMsgTarget) {
 476                         if (PVE.Utils.toolkit === 'touch') {
 477                             options.waitMsgTarget.setMasked(false);
 478                         } else {
 479                             options.waitMsgTarget.setLoading(false);
 480                         }
 481                     }
 482                     response.result = {};
 483                     try {
 484                         response.result = Ext.decode(response.responseText);
 485                     } catch(e) {}
 486                     var msg = gettext('Connection error') + ' - server offline?';
 487                     if (response.aborted) {
 488                         msg = gettext('Connection error') + ' - aborted.';
 489                     } else if (response.timedout) {
 490                         msg = gettext('Connection error') + ' - Timeout.';
 491                     } else if (response.status && response.statusText) {
 492                         msg = gettext('Connection error') + ' ' + response.status + ': ' + response.statusText;
 493                     }
 494                     response.htmlStatus = msg;
 495                     Ext.callback(callbackFn, options.scope, [options, false, response]);
 496                     Ext.callback(failureFn, options.scope, [response, options]);
 497                 }
 498             });
 499         };
 500
 501         createWrapper(reqOpts.success, reqOpts.callback, reqOpts.failure);
 502
 503         var target = newopts.waitMsgTarget;
 504         if (target) {
 505             if (PVE.Utils.toolkit === 'touch') {
 506                 target.setMasked({ xtype: 'loadmask', message: newopts.waitMsg} );
 507             } else {
 508                 // Note: ExtJS bug - this does not work when component is not rendered
 509                 target.setLoading(newopts.waitMsg);
 510             }
 511         }
 512         Ext.Ajax.request(newopts);
 513     },
 514
 515     assemble_field_data: function(values, data) {
 516         if (Ext.isObject(data)) {
 517             Ext.Object.each(data, function(name, val) {
 518                 if (values.hasOwnProperty(name)) {
 519                     var bucket = values[name];
 520                     if (!Ext.isArray(bucket)) {
 521                         bucket = values[name] = [bucket];
 522                     }
 523                     if (Ext.isArray(val)) {
 524                         values[name] = bucket.concat(val);
 525                     } else {
 526                         bucket.push(val);
 527                     }
 528                 } else {
 529                     values[name] = val;
 530                 }
 531             });
 532         }
 533     },
 534
 535     checked_command: function(orig_cmd) {
 536         PVE.Utils.API2Request({
 537             url: '/nodes/localhost/subscription',
 538             method: 'GET',
 539             //waitMsgTarget: me,
 540             failure: function(response, opts) {
 541                 Ext.Msg.alert(gettext('Error'), response.htmlStatus);
 542             },
 543             success: function(response, opts) {
 544                 var data = response.result.data;
 545
 546                 if (data.status !== 'Active') {
 547                     Ext.Msg.show({
 548                         title: gettext('No valid subscription'),
 549                         icon: Ext.Msg.WARNING,
 550                         msg: PVE.Utils.noSubKeyHtml,
 551                         buttons: Ext.Msg.OK,
 552                         callback: function(btn) {
 553                             if (btn !== 'ok') {
 554                                 return;
 555                             }
 556                             orig_cmd();
 557                         }
 558                     });
 559                 } else {
 560                     orig_cmd();
 561                 }
 562             }
 563         });
 564     },
 565
 566     task_desc_table: {
 567         diskinit: [ 'Disk', gettext('Initialize Disk with GPT') ],
 568         vncproxy: [ 'VM/CT', gettext('Console') ],
 569         spiceproxy: [ 'VM/CT', gettext('Console') + ' (Spice)' ],
 570         vncshell: [ '', gettext('Shell') ],
 571         spiceshell: [ '', gettext('Shell')  + ' (Spice)' ],
 572         qmsnapshot: [ 'VM', gettext('Snapshot') ],
 573         qmrollback: [ 'VM', gettext('Rollback') ],
 574         qmdelsnapshot: [ 'VM', gettext('Delete Snapshot') ],
 575         qmcreate: [ 'VM', gettext('Create') ],
 576         qmrestore: [ 'VM', gettext('Restore') ],
 577         qmdestroy: [ 'VM', gettext('Destroy') ],
 578         qmigrate: [ 'VM', gettext('Migrate') ],
 579         qmclone: [ 'VM', gettext('Clone') ],
 580         qmmove: [ 'VM', gettext('Move disk') ],
 581         qmtemplate: [ 'VM', gettext('Convert to template') ],
 582         qmstart: [ 'VM', gettext('Start') ],
 583         qmstop: [ 'VM', gettext('Stop') ],
 584         qmreset: [ 'VM', gettext('Reset') ],
 585         qmshutdown: [ 'VM', gettext('Shutdown') ],
 586         qmsuspend: [ 'VM', gettext('Suspend') ],
 587         qmresume: [ 'VM', gettext('Resume') ],
 588         qmconfig: [ 'VM', gettext('Configure') ],
 589         vzsnapshot: [ 'CT', gettext('Snapshot') ],
 590         vzrollback: [ 'CT', gettext('Rollback') ],
 591         vzdelsnapshot: [ 'CT', gettext('Delete Snapshot') ],
 592         vzcreate: ['CT', gettext('Create') ],
 593         vzrestore: ['CT', gettext('Restore') ],
 594         vzdestroy: ['CT', gettext('Destroy') ],
 595         vzmigrate: [ 'CT', gettext('Migrate') ],
 596         vzclone: [ 'CT', gettext('Clone') ],
 597         vztemplate: [ 'CT', gettext('Convert to template') ],
 598         vzstart: ['CT', gettext('Start') ],
 599         vzstop: ['CT', gettext('Stop') ],
 600         vzmount: ['CT', gettext('Mount') ],
 601         vzumount: ['CT', gettext('Unmount') ],
 602         vzshutdown: ['CT', gettext('Shutdown') ],
 603         vzsuspend: [ 'CT', gettext('Suspend') ],
 604         vzresume: [ 'CT', gettext('Resume') ],
 605         hamigrate: [ 'HA', gettext('Migrate') ],
 606         hastart: [ 'HA', gettext('Start') ],
 607         hastop: [ 'HA', gettext('Stop') ],
 608         srvstart: ['SRV', gettext('Start') ],
 609         srvstop: ['SRV', gettext('Stop') ],
 610         srvrestart: ['SRV', gettext('Restart') ],
 611         srvreload: ['SRV', gettext('Reload') ],
 612         cephcreatemon: ['Ceph Monitor', gettext('Create') ],
 613         cephdestroymon: ['Ceph Monitor', gettext('Destroy') ],
 614         cephcreateosd: ['Ceph OSD', gettext('Create') ],
 615         cephdestroyosd: ['Ceph OSD', gettext('Destroy') ],
 616         cephdestroypool: ['Ceph Pool', gettext('Destroy') ],
 617         imgcopy: ['', gettext('Copy data') ],
 618         imgdel: ['', gettext('Erase data') ],
 619         download: ['', gettext('Download') ],
 620         vzdump: ['', gettext('Backup') ],
 621         aptupdate: ['', gettext('Update package database') ],
 622         startall: [ '', gettext('Start all VMs and Containers') ],
 623         stopall: [ '', gettext('Stop all VMs and Containers') ],
 624         migrateall: [ '', gettext('Migrate all VMs and Containers') ]
 625     },
 626
 627     format_task_description: function(type, id) {
 628         var farray = PVE.Utils.task_desc_table[type];
 629         if (!farray) {
 630             return type;
 631         }
 632         var prefix = farray[0];
 633         var text = farray[1];
 634         if (prefix) {
 635             return prefix + ' ' + id + ' - ' + text;
 636         }
 637         return text;
 638     },
 639
 640     parse_task_upid: function(upid) {
 641         var task = {};
 642
 643         var res = upid.match(/^UPID:(\S+):([0-9A-Fa-f]{8}):([0-9A-Fa-f]{8,9}):([0-9A-Fa-f]{8}):([^:\s]+):([^:\s]*):([^:\s]+):$/);
 644         if (!res) {
 645             throw "unable to parse upid '" + upid + "'";
 646         }
 647         task.node = res[1];
 648         task.pid = parseInt(res[2], 16);
 649         task.pstart = parseInt(res[3], 16);
 650         task.starttime = parseInt(res[4], 16);
 651         task.type = res[5];
 652         task.id = res[6];
 653         task.user = res[7];
 654
 655         task.desc = PVE.Utils.format_task_description(task.type, task.id);
 656
 657         return task;
 658     },
 659
 660     format_size: function(size) {
 661         /*jslint confusion: true */
 662
 663         var units = ['', 'Ki', 'Mi', 'Gi', 'Ti', 'Pi', 'Ei', 'Zi', 'Yi'];
 664         var num = 0;
 665
 666         while (size >= 1024 && ((num++)+1) < units.length) {
 667             size = size / 1024;
 668         }
 669
 670         return size.toFixed((num > 0)?2:0) + " " + units[num] + "B";
 671     },
 672
 673     format_html_bar: function(per, text) {
 674
 675         return "<div class='pve-bar-wrap'>" + text + "<div class='pve-bar-border'>" +
 676             "<div class='pve-bar-inner' style='width:" + per + "%;'></div>" +
 677             "</div></div>";
 678
 679     },
 680
 681     format_cpu_bar: function(per1, per2, text) {
 682
 683         return "<div class='pve-bar-border'>" +
 684             "<div class='pve-bar-inner' style='width:" + per1 + "%;'></div>" +
 685             "<div class='pve-bar-inner2' style='width:" + per2 + "%;'></div>" +
 686             "<div class='pve-bar-text'>" + text + "</div>" +
 687             "</div>";
 688     },
 689
 690     format_large_bar: function(per, text) {
 691
 692         if (!text) {
 693             text = per.toFixed(1) + "%";
 694         }
 695
 696         return "<div class='pve-largebar-border'>" +
 697             "<div class='pve-largebar-inner' style='width:" + per + "%;'></div>" +
 698             "<div class='pve-largebar-text'>" + text + "</div>" +
 699             "</div>";
 700     },
 701
 702     format_duration_long: function(ut) {
 703
 704         var days = Math.floor(ut / 86400);
 705         ut -= days*86400;
 706         var hours = Math.floor(ut / 3600);
 707         ut -= hours*3600;
 708         var mins = Math.floor(ut / 60);
 709         ut -= mins*60;
 710
 711         var hours_str = '00' + hours.toString();
 712         hours_str = hours_str.substr(hours_str.length - 2);
 713         var mins_str = "00" + mins.toString();
 714         mins_str = mins_str.substr(mins_str.length - 2);
 715         var ut_str = "00" + ut.toString();
 716         ut_str = ut_str.substr(ut_str.length - 2);
 717
 718         if (days) {
 719             var ds = days > 1 ? PVE.Utils.daysText : PVE.Utils.dayText;
 720             return days.toString() + ' ' + ds + ' ' +
 721                 hours_str + ':' + mins_str + ':' + ut_str;
 722         } else {
 723             return hours_str + ':' + mins_str + ':' + ut_str;
 724         }
 725     },
 726
 727     format_duration_short: function(ut) {
 728
 729         if (ut < 60) {
 730             return ut.toString() + 's';
 731         }
 732
 733         if (ut < 3600) {
 734             var mins = ut / 60;
 735             return mins.toFixed(0) + 'm';
 736         }
 737
 738         if (ut < 86400) {
 739             var hours = ut / 3600;
 740             return hours.toFixed(0) + 'h';
 741         }
 742
 743         var days = ut / 86400;
 744         return days.toFixed(0) + 'd';
 745     },
 746
 747     yesText: gettext('Yes'),
 748     noText: gettext('No'),
 749     enabledText: gettext('Enabled'),
 750     disabledText: gettext('Disabled'),
 751     noneText: gettext('none'),
 752     errorText: gettext('Error'),
 753     unknownText: gettext('Unknown'),
 754     defaultText: gettext('Default'),
 755     daysText: gettext('days'),
 756     dayText: gettext('day'),
 757     runningText: gettext('running'),
 758     stoppedText: gettext('stopped'),
 759     neverText: gettext('never'),
 760     totalText: gettext('Total'),
 761     usedText: gettext('Used'),
 762     directoryText: gettext('Directory'),
 763     imagesText: gettext('Disk image'),
 764     backupFileText: gettext('VZDump backup file'),
 765     vztmplText: gettext('Container template'),
 766     isoImageText: gettext('ISO image'),
 767     containersText: gettext('Container'),
 768     stateText: gettext('State'),
 769     groupText: gettext('Group'),
 770
 771     format_expire: function(date) {
 772         if (!date) {
 773             return PVE.Utils.neverText;
 774         }
 775         return Ext.Date.format(date, "Y-m-d");
 776     },
 777
 778     format_storage_type: function(value) {
 779         if (value === 'dir') {
 780             return PVE.Utils.directoryText;
 781         } else if (value === 'nfs') {
 782             return 'NFS';
 783         } else if (value === 'glusterfs') {
 784             return 'GlusterFS';
 785         } else if (value === 'lvm') {
 786             return 'LVM';
 787         } else if (value === 'lvmthin') {
 788             return 'LVM-Thin';
 789         } else if (value === 'iscsi') {
 790             return 'iSCSI';
 791         } else if (value === 'rbd') {
 792             return 'RBD';
 793         } else if (value === 'sheepdog') {
 794             return 'Sheepdog';
 795         } else if (value === 'zfs') {
 796             return 'ZFS over iSCSI';
 797         } else if (value === 'zfspool') {
 798             return 'ZFS';
 799         } else if (value === 'iscsidirect') {
 800             return 'iSCSIDirect';
 801         } else if (value === 'drbd') {
 802             return 'DRBD';
 803         } else {
 804             return PVE.Utils.unknownText;
 805         }
 806     },
 807
 808     format_boolean_with_default: function(value) {
 809         if (Ext.isDefined(value) && value !== '__default__') {
 810             return value ? PVE.Utils.yesText : PVE.Utils.noText;
 811         }
 812         return PVE.Utils.defaultText;
 813     },
 814
 815     format_boolean: function(value) {
 816         return value ? PVE.Utils.yesText : PVE.Utils.noText;
 817     },
 818
 819     format_neg_boolean: function(value) {
 820         return !value ? PVE.Utils.yesText : PVE.Utils.noText;
 821     },
 822
 823     format_enabled_toggle: function(value) {
 824         return value ? PVE.Utils.enabledText :PVE.Utils.disabledText;
 825     },
 826
 827     format_ha: function(value) {
 828         var text = PVE.Utils.format_boolean(value.managed);
 829
 830         if (value.managed) {
 831             text += ', ' + PVE.Utils.stateText + ': ';
 832             text += value.state || PVE.Utils.noneText;
 833
 834             text += ', ' +  PVE.Utils.groupText + ': ';
 835             text += value.group || PVE.Utils.noneText;
 836         }
 837
 838         return text;
 839     },
 840
 841     format_content_types: function(value) {
 842         var cta = [];
 843
 844         Ext.each(value.split(',').sort(), function(ct) {
 845             if (ct === 'images') {
 846                 cta.push(PVE.Utils.imagesText);
 847             } else if (ct === 'backup') {
 848                 cta.push(PVE.Utils.backupFileText);
 849             } else if (ct === 'vztmpl') {
 850                 cta.push(PVE.Utils.vztmplText);
 851             } else if (ct === 'iso') {
 852                 cta.push(PVE.Utils.isoImageText);
 853             } else if (ct === 'rootdir') {
 854                 cta.push(PVE.Utils.containersText);
 855             }
 856         });
 857
 858         return cta.join(', ');
 859     },
 860
 861     render_storage_content: function(value, metaData, record) {
 862         var data = record.data;
 863         if (Ext.isNumber(data.channel) &&
 864             Ext.isNumber(data.id) &&
 865             Ext.isNumber(data.lun)) {
 866             return "CH " +
 867                 Ext.String.leftPad(data.channel,2, '0') +
 868                 " ID " + data.id + " LUN " + data.lun;
 869         }
 870         return data.volid.replace(/^.*:(.*\/)?/,'');
 871     },
 872
 873     render_serverity: function (value) {
 874         return PVE.Utils.log_severity_hash[value] || value;
 875     },
 876
 877     render_cpu: function(value, metaData, record, rowIndex, colIndex, store) {
 878
 879         if (!(record.data.uptime && Ext.isNumeric(value))) {
 880             return '';
 881         }
 882
 883         var maxcpu = record.data.maxcpu || 1;
 884
 885         if (!Ext.isNumeric(maxcpu) && (maxcpu >= 1)) {
 886             return '';
 887         }
 888
 889         var per = value * 100;
 890
 891         return per.toFixed(1) + '% of ' + maxcpu.toString() + (maxcpu > 1 ? 'CPUs' : 'CPU');
 892     },
 893
 894     render_size: function(value, metaData, record, rowIndex, colIndex, store) {
 895         /*jslint confusion: true */
 896
 897         if (!Ext.isNumeric(value)) {
 898             return '';
 899         }
 900
 901         return PVE.Utils.format_size(value);
 902     },
 903
 904     render_bandwidth: function(value) {
 905         if (!Ext.isNumeric(value)) {
 906             return '';
 907         }
 908
 909         return PVE.Utils.format_size(value) + '/s';
 910     },
 911
 912     render_timestamp: function(value, metaData, record, rowIndex, colIndex, store) {
 913         var servertime = new Date(value * 1000);
 914         return Ext.Date.format(servertime, 'Y-m-d H:i:s');
 915     },
 916
 917     render_timestamp_human_readable: function(value) {
 918         return Ext.Date.format(new Date(value * 1000), 'l d F Y H:i:s');
 919     },
 920
 921     calculate_mem_usage: function(data) {
 922         if (!Ext.isNumeric(data.mem) ||
 923             data.maxmem === 0 ||
 924             data.uptime < 1) {
 925             return -1;
 926         }
 927
 928         return (data.mem / data.maxmem);
 929     },
 930
 931     render_mem_usage_percent: function(value, metaData, record, rowIndex, colIndex, store) {
 932         if (!Ext.isNumeric(value) || value === -1) {
 933             return '';
 934         }
 935         if (value > 1 ) {
 936             // we got no percentage but bytes
 937             var mem = value;
 938             var maxmem = record.data.maxmem;
 939             if (!record.data.uptime ||
 940                 maxmem === 0 ||
 941                 !Ext.isNumeric(mem)) {
 942                 return '';
 943             }
 944
 945             return ((mem*100)/maxmem).toFixed(1) + " %";
 946         }
 947         return (value*100).toFixed(1) + " %";
 948     },
 949
 950     render_mem_usage: function(value, metaData, record, rowIndex, colIndex, store) {
 951
 952         var mem = value;
 953         var maxmem = record.data.maxmem;
 954
 955         if (!record.data.uptime) {
 956             return '';
 957         }
 958
 959         if (!(Ext.isNumeric(mem) && maxmem)) {
 960             return '';
 961         }
 962
 963         return PVE.Utils.render_size(value);
 964     },
 965
 966     calculate_disk_usage: function(data) {
 967
 968         if (!Ext.isNumeric(data.disk) ||
 969             data.type === 'qemu' ||
 970             (data.type === 'lxc' && data.uptime === 0) ||
 971             data.maxdisk === 0) {
 972             return -1;
 973         }
 974
 975         return (data.disk / data.maxdisk);
 976     },
 977
 978     render_disk_usage_percent: function(value, metaData, record, rowIndex, colIndex, store) {
 979         if (!Ext.isNumeric(value) || value === -1) {
 980             return '';
 981         }
 982
 983         return (value * 100).toFixed(1) + " %";
 984     },
 985
 986     render_disk_usage: function(value, metaData, record, rowIndex, colIndex, store) {
 987
 988         var disk = value;
 989         var maxdisk = record.data.maxdisk;
 990         var type = record.data.type;
 991
 992         if (!Ext.isNumeric(disk) ||
 993             type === 'qemu' ||
 994             maxdisk === 0 ||
 995             (type === 'lxc' && record.data.uptime === 0)) {
 996             return '';
 997         }
 998
 999         return PVE.Utils.render_size(value);
1000     },
1001
1002     render_resource_type: function(value, metaData, record, rowIndex, colIndex, store) {
1003
1004         var icon = '';
1005         var gridcls = '';
1006
1007         switch (value) {
1008             case 'lxc': icon = 'cube';
1009                         gridcls = '-stopped';
1010                         break;
1011             case 'qemu': icon = 'desktop';
1012                          gridcls = '-stopped';
1013                          break;
1014             case 'node': icon = 'building';
1015                          gridcls = '-offline';
1016                          break;
1017             case 'storage': icon = 'database'; break;
1018             case 'pool': icon = 'tags'; break;
1019             default: icon = 'file';
1020         }
1021
1022         if (value === 'lxc' || value === 'qemu') {
1023             if (record.data.running && record.data.status !== 'paused') {
1024                 gridcls = '-running';
1025             } else if (record.data.running) {
1026                 gridcls = '-paused';
1027             }
1028             if (record.data.template) {
1029                 icon = 'file-o';
1030                 gridcls = '-template-' + value;
1031             }
1032         } else if (value === 'node') {
1033             if (record.data.running) {
1034                 gridcls = '-online';
1035             }
1036         }
1037
1038         // overwrite anything else
1039         if (record.data.hastate === 'error') {
1040             gridcls = '-offline';
1041         }
1042
1043         var fa = '<i class="fa fa-fw x-fa-grid' + gridcls  +  ' fa-' + icon  + '"></i> ';
1044         return fa + value;
1045     },
1046
1047     render_uptime: function(value, metaData, record, rowIndex, colIndex, store) {
1048
1049         var uptime = value;
1050
1051         if (uptime === undefined) {
1052             return '';
1053         }
1054
1055         if (uptime <= 0) {
1056             return '-';
1057         }
1058
1059         return PVE.Utils.format_duration_long(uptime);
1060     },
1061
1062     render_support_level: function(value, metaData, record) {
1063         return PVE.Utils.support_level_hash[value] || '-';
1064     },
1065
1066     render_upid: function(value, metaData, record) {
1067         var type = record.data.type;
1068         var id = record.data.id;
1069
1070         return PVE.Utils.format_task_description(type, id);
1071     },
1072
1073     /* render functions for new status panel */
1074
1075     render_usage: function(val) {
1076         return (val*100).toFixed(2) + '%';
1077     },
1078
1079     render_cpu_usage: function(val, max) {
1080         return Ext.String.format(gettext('{0}% of {1}') +
1081             ' ' + gettext('CPU(s)'), (val*100).toFixed(2), max);
1082     },
1083
1084     render_size_usage: function(val, max) {
1085         if (max === 0) {
1086             return gettext('N/A');
1087         }
1088         return (val*100/max).toFixed(2) + '% '+ '(' +
1089             Ext.String.format(gettext('{0} of {1}'),
1090             PVE.Utils.render_size(val), PVE.Utils.render_size(max)) + ')';
1091     },
1092
1093     /* this is different for nodes */
1094     render_node_cpu_usage: function(value, record) {
1095         return PVE.Utils.render_cpu_usage(value, record.cpus);
1096     },
1097
1098     /* this is different for nodes */
1099     render_node_size_usage: function(record) {
1100         return PVE.Utils.render_size_usage(record.used, record.total);
1101     },
1102
1103     dialog_title: function(subject, create, isAdd) {
1104         if (create) {
1105             if (isAdd) {
1106                 return gettext('Add') + ': ' + subject;
1107             } else {
1108                 return gettext('Create') + ': ' + subject;
1109             }
1110         } else {
1111             return gettext('Edit') + ': ' + subject;
1112         }
1113     },
1114
1115     windowHostname: function() {
1116         return window.location.hostname.replace(PVE.Utils.IP6_bracket_match,
1117             function(m, addr, offset, original) { return addr; });
1118     },
1119
1120     openDefaultConsoleWindow: function(allowSpice, vmtype, vmid, nodename, vmname) {
1121         var dv = PVE.Utils.defaultViewer(allowSpice);
1122         PVE.Utils.openConsoleWindow(dv, vmtype, vmid, nodename, vmname);
1123     },
1124
1125     openConsoleWindow: function(viewer, vmtype, vmid, nodename, vmname) {
1126         // kvm, lxc, shell, upgrade
1127
1128         if (vmid == undefined && (vmtype === 'kvm' || vmtype === 'lxc')) {
1129             throw "missing vmid";
1130         }
1131
1132         if (!nodename) {
1133             throw "no nodename specified";
1134         }
1135
1136         if (viewer === 'html5') {
1137             PVE.Utils.openVNCViewer(vmtype, vmid, nodename, vmname);
1138         } else if (viewer === 'vv') {
1139             var url;
1140             var params = { proxy: PVE.Utils.windowHostname() };
1141             if (vmtype === 'kvm') {
1142                 url = '/nodes/' + nodename + '/qemu/' + vmid.toString() + '/spiceproxy';
1143                 PVE.Utils.openSpiceViewer(url, params);
1144             } else if (vmtype === 'lxc') {
1145                 url = '/nodes/' + nodename + '/lxc/' + vmid.toString() + '/spiceproxy';
1146                 PVE.Utils.openSpiceViewer(url, params);
1147             } else if (vmtype === 'shell') {
1148                 url = '/nodes/' + nodename + '/spiceshell';
1149                 PVE.Utils.openSpiceViewer(url, params);
1150             } else if (vmtype === 'upgrade') {
1151                 url = '/nodes/' + nodename + '/spiceshell';
1152                 params.upgrade = 1;
1153                 PVE.Utils.openSpiceViewer(url, params);
1154             }
1155         } else {
1156             throw "unknown viewer type";
1157         }
1158     },
1159
1160     defaultViewer: function(allowSpice) {
1161         var vncdefault = 'html5';
1162         var dv = PVE.VersionInfo.console || vncdefault;
1163         if (dv === 'vv' && !allowSpice) {
1164             dv = vncdefault;
1165         }
1166
1167         return dv;
1168     },
1169
1170     openVNCViewer: function(vmtype, vmid, nodename, vmname) {
1171         var url = Ext.urlEncode({
1172             console: vmtype, // kvm, lxc, upgrade or shell
1173             novnc: 1,
1174             vmid: vmid,
1175             vmname: vmname,
1176             node: nodename
1177         });
1178         var nw = window.open("?" + url, '_blank', "innerWidth=745,innerheight=427");
1179         nw.focus();
1180     },
1181
1182     openSpiceViewer: function(url, params){
1183
1184         var downloadWithName = function(uri, name) {
1185             var link = Ext.DomHelper.append(document.body, {
1186                 tag: 'a',
1187                 href: uri,
1188                 css : 'display:none;visibility:hidden;height:0px;'
1189             });
1190
1191             // Note: we need to tell android the correct file name extension
1192             // but we do not set 'download' tag for other environments, because
1193             // It can have strange side effects (additional user prompt on firefox)
1194             var andriod = navigator.userAgent.match(/Android/i) ? true : false;
1195             if (andriod) {
1196                 link.download = name;
1197             }
1198
1199             if (link.fireEvent) {
1200                 link.fireEvent('onclick');
1201             } else {
1202                 var evt = document.createEvent("MouseEvents");
1203                 evt.initMouseEvent('click', true, true, window, 1, 0, 0, 0, 0, false, false, false, false, 0, null);
1204                 link.dispatchEvent(evt);
1205             }
1206         };
1207
1208         PVE.Utils.API2Request({
1209             url: url,
1210             params: params,
1211             method: 'POST',
1212             failure: function(response, opts){
1213                 Ext.Msg.alert('Error', response.htmlStatus);
1214             },
1215             success: function(response, opts){
1216                 var raw = "[virt-viewer]\n";
1217                 Ext.Object.each(response.result.data, function(k, v) {
1218                     raw += k + "=" + v + "\n";
1219                 });
1220                 var url = 'data:application/x-virt-viewer;charset=UTF-8,' +
1221                     encodeURIComponent(raw);
1222
1223                 downloadWithName(url, "pve-spice.vv");
1224             }
1225         });
1226     },
1227
1228     // comp.setLoading() is buggy in ExtJS 4.0.7, so we
1229     // use el.mask() instead
1230     setErrorMask: function(comp, msg) {
1231         var el = comp.el;
1232         if (!el) {
1233             return;
1234         }
1235         if (!msg) {
1236             el.unmask();
1237         } else {
1238             if (msg === true) {
1239                 el.mask(gettext("Loading..."));
1240             } else {
1241                 el.mask(msg);
1242             }
1243         }
1244     },
1245
1246     monStoreErrors: function(me, store) {
1247         me.mon(store, 'beforeload', function(s, operation, eOpts) {
1248             if (!me.loadCount) {
1249                 me.loadCount = 0; // make sure it is numeric
1250                 PVE.Utils.setErrorMask(me, true);
1251             }
1252         });
1253
1254         // only works with 'pve' proxy
1255         me.mon(store.proxy, 'afterload', function(proxy, request, success) {
1256             me.loadCount++;
1257
1258             if (success) {
1259                 PVE.Utils.setErrorMask(me, false);
1260                 return;
1261             }
1262
1263             var msg;
1264             /*jslint nomen: true */
1265             var operation = request._operation;
1266             var error = operation.getError();
1267             if (error.statusText) {
1268                 msg = error.statusText + ' (' + error.status + ')';
1269             } else {
1270                 msg = gettext('Connection error');
1271             }
1272             PVE.Utils.setErrorMask(me, msg);
1273         });
1274     },
1275
1276     openTreeConsole: function(tree, record, item, index, e) {
1277         e.stopEvent();
1278         var nodename = record.data.node;
1279         var vmid = record.data.vmid;
1280         var vmname = record.data.name;
1281         if (record.data.type === 'qemu' && !record.data.template) {
1282             PVE.Utils.API2Request({
1283                 url: '/nodes/' + nodename + '/qemu/' + vmid + '/status/current',
1284                 failure: function(response, opts) {
1285                     Ext.Msg.alert('Error', response.htmlStatus);
1286                 },
1287                 success: function(response, opts) {
1288                     var allowSpice = response.result.data.spice;
1289                     PVE.Utils.openDefaultConsoleWindow(allowSpice, 'kvm', vmid, nodename, vmname);
1290                 }
1291             });
1292         } else if (record.data.type === 'lxc' && !record.data.template) {
1293             PVE.Utils.openDefaultConsoleWindow(true, 'lxc', vmid, nodename, vmname);
1294         }
1295     },
1296
1297     // test automation helper
1298     call_menu_handler: function(menu, text) {
1299
1300         var list = menu.query('menuitem');
1301
1302         Ext.Array.each(list, function(item) {
1303             if (item.text === text) {
1304                 if (item.handler) {
1305                     item.handler();
1306                     return 1;
1307                 } else {
1308                     return undefined;
1309                 }
1310             }
1311         });
1312     },
1313
1314     createCmdMenu: function(v, record, item, index, event) {
1315         event.stopEvent();
1316         if (!(v instanceof Ext.tree.View)) {
1317             v.select(record);
1318         }
1319         var menu;
1320
1321         if (record.data.type === 'qemu' && !record.data.template) {
1322             menu = Ext.create('PVE.qemu.CmdMenu', {
1323                 pveSelNode: record
1324             });
1325         } else if (record.data.type === 'qemu' && record.data.template) {
1326             menu = Ext.create('PVE.qemu.TemplateMenu', {
1327                 pveSelNode: record
1328             });
1329         } else if (record.data.type === 'lxc' && !record.data.template) {
1330             menu = Ext.create('PVE.lxc.CmdMenu', {
1331                 pveSelNode: record
1332             });
1333         } else if (record.data.type === 'lxc' && record.data.template) {
1334             /* since clone does not work reliably, disable for now
1335             menu = Ext.create('PVE.lxc.TemplateMenu', {
1336                 pveSelNode: record
1337             });
1338             */
1339             return;
1340
1341         } else if (record.data.type === 'node' ){
1342             menu = Ext.create('PVE.node.CmdMenu', {
1343                 nodename: record.data.node
1344             });
1345
1346         } else {
1347             return;
1348         }
1349
1350         menu.showAt(event.getXY());
1351     }},
1352
1353     // helper for deleting field which are set to there default values
1354     delete_if_default: function(values, fieldname, default_val, create) {
1355         if (values[fieldname] === '' || values[fieldname] === default_val) {
1356             if (!create) {
1357                 if (values['delete']) {
1358                     values['delete'] += ',' + fieldname;
1359                 } else {
1360                     values['delete'] = fieldname;
1361                 }
1362             }
1363
1364             delete values[fieldname];
1365         }
1366     },
1367
1368     singleton: true,
1369     constructor: function() {
1370         var me = this;
1371         Ext.apply(me, me.utilities);
1372
1373         var IPV4_OCTET = "(?:25[0-5]|(?:[1-9]|1[0-9]|2[0-4])?[0-9])";
1374         var IPV4_REGEXP = "(?:(?:" + IPV4_OCTET + "\\.){3}" + IPV4_OCTET + ")";
1375         var IPV6_H16 = "(?:[0-9a-fA-F]{1,4})";
1376         var IPV6_LS32 = "(?:(?:" + IPV6_H16 + ":" + IPV6_H16 + ")|" + IPV4_REGEXP + ")";
1377
1378
1379         me.IP4_match = new RegExp("^(?:" + IPV4_REGEXP + ")$");
1380         me.IP4_cidr_match = new RegExp("^(?:" + IPV4_REGEXP + ")\/([0-9]{1,2})$");
1381
1382         var IPV6_REGEXP = "(?:" +
1383             "(?:(?:"                                                  + "(?:" + IPV6_H16 + ":){6})" + IPV6_LS32 + ")|" +
1384             "(?:(?:"                                         +   "::" + "(?:" + IPV6_H16 + ":){5})" + IPV6_LS32 + ")|" +
1385             "(?:(?:(?:"                           + IPV6_H16 + ")?::" + "(?:" + IPV6_H16 + ":){4})" + IPV6_LS32 + ")|" +
1386             "(?:(?:(?:(?:" + IPV6_H16 + ":){0,1}" + IPV6_H16 + ")?::" + "(?:" + IPV6_H16 + ":){3})" + IPV6_LS32 + ")|" +
1387             "(?:(?:(?:(?:" + IPV6_H16 + ":){0,2}" + IPV6_H16 + ")?::" + "(?:" + IPV6_H16 + ":){2})" + IPV6_LS32 + ")|" +
1388             "(?:(?:(?:(?:" + IPV6_H16 + ":){0,3}" + IPV6_H16 + ")?::" + "(?:" + IPV6_H16 + ":){1})" + IPV6_LS32 + ")|" +
1389             "(?:(?:(?:(?:" + IPV6_H16 + ":){0,4}" + IPV6_H16 + ")?::" +                         ")" + IPV6_LS32 + ")|" +
1390             "(?:(?:(?:(?:" + IPV6_H16 + ":){0,5}" + IPV6_H16 + ")?::" +                         ")" + IPV6_H16  + ")|" +
1391             "(?:(?:(?:(?:" + IPV6_H16 + ":){0,7}" + IPV6_H16 + ")?::" +                         ")"             + ")"  +
1392             ")";
1393
1394         me.IP6_match = new RegExp("^(?:" + IPV6_REGEXP + ")$");
1395         me.IP6_cidr_match = new RegExp("^(?:" + IPV6_REGEXP + ")\/([0-9]{1,3})$");
1396         me.IP6_bracket_match = new RegExp("^\\[(" + IPV6_REGEXP + ")\\]");
1397
1398         me.IP64_match = new RegExp("^(?:" + IPV6_REGEXP + "|" + IPV4_REGEXP + ")$");
1399
1400         var DnsName_REGEXP = "(?:(([a-zA-Z0-9]([a-zA-Z0-9\\-]*[a-zA-Z0-9])?)\\.)*([A-Za-z0-9]([A-Za-z0-9\\-]*[A-Za-z0-9])?))";
1401         me.DnsName_match = new RegExp("^" + DnsName_REGEXP + "$");
1402
1403         me.HostPort_match = new RegExp("^(" + IPV4_REGEXP + "|" + DnsName_REGEXP + ")(:\\d+)?$");
1404         me.HostPortBrackets_match = new RegExp("^\\[(?:" + IPV6_REGEXP + "|" + IPV4_REGEXP + "|" + DnsName_REGEXP + ")\\](:\\d+)?$");
1405         me.IP6_dotnotation_match = new RegExp("^" + IPV6_REGEXP + "(\\.\\d+)?$");
1406     }
1407 });
1408