const pveOnlineHelpInfo = {
"ceph_rados_block_devices" : {
"link" : "/pve-docs/chapter-pvesm.html#ceph_rados_block_devices",
"title" : "Ceph RADOS Block Devices (RBD)"
},
"chapter_ha_manager" : {
"link" : "/pve-docs/chapter-ha-manager.html#chapter_ha_manager",
"title" : "High Availability"
},
"chapter_lvm" : {
"link" : "/pve-docs/chapter-sysadmin.html#chapter_lvm",
"title" : "Logical Volume Manager (LVM)"
},
"chapter_notifications" : {
"link" : "/pve-docs/chapter-notifications.html#chapter_notifications",
"title" : "Notifications"
},
"chapter_pct" : {
"link" : "/pve-docs/chapter-pct.html#chapter_pct",
"title" : "Proxmox Container Toolkit"
},
"chapter_pve_firewall" : {
"link" : "/pve-docs/chapter-pve-firewall.html#chapter_pve_firewall",
"title" : "Proxmox VE Firewall"
},
"chapter_pveceph" : {
"link" : "/pve-docs/chapter-pveceph.html#chapter_pveceph",
"title" : "Deploy Hyper-Converged Ceph Cluster"
},
"chapter_pvecm" : {
"link" : "/pve-docs/chapter-pvecm.html#chapter_pvecm",
"title" : "Cluster Manager"
},
"chapter_pvesdn" : {
"link" : "/pve-docs/chapter-pvesdn.html#chapter_pvesdn",
"title" : "Software-Defined Network"
},
"chapter_pvesr" : {
"link" : "/pve-docs/chapter-pvesr.html#chapter_pvesr",
"title" : "Storage Replication"
},
"chapter_storage" : {
"link" : "/pve-docs/chapter-pvesm.html#chapter_storage",
"title" : "Proxmox VE Storage"
},
"chapter_system_administration" : {
"link" : "/pve-docs/chapter-sysadmin.html#chapter_system_administration",
"title" : "Host System Administration"
},
"chapter_user_management" : {
"link" : "/pve-docs/chapter-pveum.html#chapter_user_management",
"title" : "User Management"
},
"chapter_virtual_machines" : {
"link" : "/pve-docs/chapter-qm.html#chapter_virtual_machines",
"title" : "QEMU/KVM Virtual Machines"
},
"chapter_vzdump" : {
"link" : "/pve-docs/chapter-vzdump.html#chapter_vzdump",
"title" : "Backup and Restore"
},
"chapter_zfs" : {
"link" : "/pve-docs/chapter-sysadmin.html#chapter_zfs",
"title" : "ZFS on Linux"
},
"datacenter_configuration_file" : {
"link" : "/pve-docs/pve-admin-guide.html#datacenter_configuration_file",
"title" : "Datacenter Configuration"
},
"external_metric_server" : {
"link" : "/pve-docs/chapter-sysadmin.html#external_metric_server",
"title" : "External Metric Server"
},
"getting_help" : {
"link" : "/pve-docs/pve-admin-guide.html#getting_help",
"title" : "Getting Help"
},
"gui_my_settings" : {
"link" : "/pve-docs/chapter-pve-gui.html#gui_my_settings",
"subtitle" : "My Settings",
"title" : "Graphical User Interface"
},
"ha_manager_crs" : {
"link" : "/pve-docs/chapter-ha-manager.html#ha_manager_crs",
"subtitle" : "Cluster Resource Scheduling",
"title" : "High Availability"
},
"ha_manager_fencing" : {
"link" : "/pve-docs/chapter-ha-manager.html#ha_manager_fencing",
"subtitle" : "Fencing",
"title" : "High Availability"
},
"ha_manager_groups" : {
"link" : "/pve-docs/chapter-ha-manager.html#ha_manager_groups",
"subtitle" : "Groups",
"title" : "High Availability"
},
"ha_manager_resource_config" : {
"link" : "/pve-docs/chapter-ha-manager.html#ha_manager_resource_config",
"subtitle" : "Resources",
"title" : "High Availability"
},
"ha_manager_resources" : {
"link" : "/pve-docs/chapter-ha-manager.html#ha_manager_resources",
"subtitle" : "Resources",
"title" : "High Availability"
},
"ha_manager_shutdown_policy" : {
"link" : "/pve-docs/chapter-ha-manager.html#ha_manager_shutdown_policy",
"subtitle" : "Shutdown Policy",
"title" : "High Availability"
},
"markdown_basics" : {
"link" : "/pve-docs/pve-admin-guide.html#markdown_basics",
"title" : "Markdown Primer"
},
"metric_server_graphite" : {
"link" : "/pve-docs/chapter-sysadmin.html#metric_server_graphite",
"subtitle" : "Graphite server configuration",
"title" : "External Metric Server"
},
"metric_server_influxdb" : {
"link" : "/pve-docs/chapter-sysadmin.html#metric_server_influxdb",
"subtitle" : "Influxdb plugin configuration",
"title" : "External Metric Server"
},
"notification_matchers" : {
"link" : "/pve-docs/chapter-notifications.html#notification_matchers",
"subtitle" : "Notification Matchers",
"title" : "Notifications"
},
"notification_targets_gotify" : {
"link" : "/pve-docs/chapter-notifications.html#notification_targets_gotify",
"subtitle" : "Gotify",
"title" : "Notifications"
},
"notification_targets_sendmail" : {
"link" : "/pve-docs/chapter-notifications.html#notification_targets_sendmail",
"subtitle" : "Sendmail",
"title" : "Notifications"
},
"notification_targets_smtp" : {
"link" : "/pve-docs/chapter-notifications.html#notification_targets_smtp",
"subtitle" : "SMTP",
"title" : "Notifications"
},
"pct_configuration" : {
"link" : "/pve-docs/chapter-pct.html#pct_configuration",
"subtitle" : "Configuration",
"title" : "Proxmox Container Toolkit"
},
"pct_container_images" : {
"link" : "/pve-docs/chapter-pct.html#pct_container_images",
"subtitle" : "Container Images",
"title" : "Proxmox Container Toolkit"
},
"pct_container_network" : {
"link" : "/pve-docs/chapter-pct.html#pct_container_network",
"subtitle" : "Network",
"title" : "Proxmox Container Toolkit"
},
"pct_container_storage" : {
"link" : "/pve-docs/chapter-pct.html#pct_container_storage",
"subtitle" : "Container Storage",
"title" : "Proxmox Container Toolkit"
},
"pct_cpu" : {
"link" : "/pve-docs/chapter-pct.html#pct_cpu",
"subtitle" : "CPU",
"title" : "Proxmox Container Toolkit"
},
"pct_general" : {
"link" : "/pve-docs/chapter-pct.html#pct_general",
"subtitle" : "General Settings",
"title" : "Proxmox Container Toolkit"
},
"pct_memory" : {
"link" : "/pve-docs/chapter-pct.html#pct_memory",
"subtitle" : "Memory",
"title" : "Proxmox Container Toolkit"
},
"pct_migration" : {
"link" : "/pve-docs/chapter-pct.html#pct_migration",
"subtitle" : "Migration",
"title" : "Proxmox Container Toolkit"
},
"pct_options" : {
"link" : "/pve-docs/chapter-pct.html#pct_options",
"subtitle" : "Options",
"title" : "Proxmox Container Toolkit"
},
"pct_startup_and_shutdown" : {
"link" : "/pve-docs/chapter-pct.html#pct_startup_and_shutdown",
"subtitle" : "Automatic Start and Shutdown of Containers",
"title" : "Proxmox Container Toolkit"
},
"proxmox_node_management" : {
"link" : "/pve-docs/chapter-sysadmin.html#proxmox_node_management",
"title" : "Proxmox Node Management"
},
"pve_admin_guide" : {
"link" : "/pve-docs/pve-admin-guide.html",
"title" : "Proxmox VE Administration Guide"
},
"pve_ceph_install" : {
"link" : "/pve-docs/chapter-pveceph.html#pve_ceph_install",
"subtitle" : "CLI Installation of Ceph Packages",
"title" : "Deploy Hyper-Converged Ceph Cluster"
},
"pve_ceph_osds" : {
"link" : "/pve-docs/chapter-pveceph.html#pve_ceph_osds",
"subtitle" : "Ceph OSDs",
"title" : "Deploy Hyper-Converged Ceph Cluster"
},
"pve_ceph_pools" : {
"link" : "/pve-docs/chapter-pveceph.html#pve_ceph_pools",
"subtitle" : "Ceph Pools",
"title" : "Deploy Hyper-Converged Ceph Cluster"
},
"pve_documentation_index" : {
"link" : "/pve-docs/index.html",
"title" : "Proxmox VE Documentation Index"
},
"pve_firewall_cluster_wide_setup" : {
"link" : "/pve-docs/chapter-pve-firewall.html#pve_firewall_cluster_wide_setup",
"subtitle" : "Cluster Wide Setup",
"title" : "Proxmox VE Firewall"
},
"pve_firewall_host_specific_configuration" : {
"link" : "/pve-docs/chapter-pve-firewall.html#pve_firewall_host_specific_configuration",
"subtitle" : "Host Specific Configuration",
"title" : "Proxmox VE Firewall"
},
"pve_firewall_ip_aliases" : {
"link" : "/pve-docs/chapter-pve-firewall.html#pve_firewall_ip_aliases",
"subtitle" : "IP Aliases",
"title" : "Proxmox VE Firewall"
},
"pve_firewall_ip_sets" : {
"link" : "/pve-docs/chapter-pve-firewall.html#pve_firewall_ip_sets",
"subtitle" : "IP Sets",
"title" : "Proxmox VE Firewall"
},
"pve_firewall_security_groups" : {
"link" : "/pve-docs/chapter-pve-firewall.html#pve_firewall_security_groups",
"subtitle" : "Security Groups",
"title" : "Proxmox VE Firewall"
},
"pve_firewall_vm_container_configuration" : {
"link" : "/pve-docs/chapter-pve-firewall.html#pve_firewall_vm_container_configuration",
"subtitle" : "VM/Container Configuration",
"title" : "Proxmox VE Firewall"
},
"pve_service_daemons" : {
"link" : "/pve-docs/index.html#_service_daemons",
"title" : "Service Daemons"
},
"pveceph_fs" : {
"link" : "/pve-docs/chapter-pveceph.html#pveceph_fs",
"subtitle" : "CephFS",
"title" : "Deploy Hyper-Converged Ceph Cluster"
},
"pveceph_fs_create" : {
"link" : "/pve-docs/chapter-pveceph.html#pveceph_fs_create",
"subtitle" : "Create CephFS",
"title" : "Deploy Hyper-Converged Ceph Cluster"
},
"pvecm_create_cluster" : {
"link" : "/pve-docs/chapter-pvecm.html#pvecm_create_cluster",
"subtitle" : "Create a Cluster",
"title" : "Cluster Manager"
},
"pvecm_join_node_to_cluster" : {
"link" : "/pve-docs/chapter-pvecm.html#pvecm_join_node_to_cluster",
"subtitle" : "Adding Nodes to the Cluster",
"title" : "Cluster Manager"
},
"pvesdn_config_controllers" : {
"link" : "/pve-docs/chapter-pvesdn.html#pvesdn_config_controllers",
"subtitle" : "Controllers",
"title" : "Software-Defined Network"
},
"pvesdn_config_vnet" : {
"link" : "/pve-docs/chapter-pvesdn.html#pvesdn_config_vnet",
"subtitle" : "VNets",
"title" : "Software-Defined Network"
},
"pvesdn_config_zone" : {
"link" : "/pve-docs/chapter-pvesdn.html#pvesdn_config_zone",
"subtitle" : "Zones",
"title" : "Software-Defined Network"
},
"pvesdn_controller_plugin_evpn" : {
"link" : "/pve-docs/chapter-pvesdn.html#pvesdn_controller_plugin_evpn",
"subtitle" : "EVPN Controller",
"title" : "Software-Defined Network"
},
"pvesdn_dns_plugin_powerdns" : {
"link" : "/pve-docs/chapter-pvesdn.html#pvesdn_dns_plugin_powerdns",
"subtitle" : "PowerDNS Plugin",
"title" : "Software-Defined Network"
},
"pvesdn_ipam_plugin_netbox" : {
"link" : "/pve-docs/chapter-pvesdn.html#pvesdn_ipam_plugin_netbox",
"subtitle" : "NetBox IPAM Plugin",
"title" : "Software-Defined Network"
},
"pvesdn_ipam_plugin_phpipam" : {
"link" : "/pve-docs/chapter-pvesdn.html#pvesdn_ipam_plugin_phpipam",
"subtitle" : "phpIPAM Plugin",
"title" : "Software-Defined Network"
},
"pvesdn_ipam_plugin_pveipam" : {
"link" : "/pve-docs/chapter-pvesdn.html#pvesdn_ipam_plugin_pveipam",
"subtitle" : "PVE IPAM Plugin",
"title" : "Software-Defined Network"
},
"pvesdn_zone_plugin_evpn" : {
"link" : "/pve-docs/chapter-pvesdn.html#pvesdn_zone_plugin_evpn",
"subtitle" : "EVPN Zones",
"title" : "Software-Defined Network"
},
"pvesdn_zone_plugin_qinq" : {
"link" : "/pve-docs/chapter-pvesdn.html#pvesdn_zone_plugin_qinq",
"subtitle" : "QinQ Zones",
"title" : "Software-Defined Network"
},
"pvesdn_zone_plugin_simple" : {
"link" : "/pve-docs/chapter-pvesdn.html#pvesdn_zone_plugin_simple",
"subtitle" : "Simple Zones",
"title" : "Software-Defined Network"
},
"pvesdn_zone_plugin_vlan" : {
"link" : "/pve-docs/chapter-pvesdn.html#pvesdn_zone_plugin_vlan",
"subtitle" : "VLAN Zones",
"title" : "Software-Defined Network"
},
"pvesdn_zone_plugin_vxlan" : {
"link" : "/pve-docs/chapter-pvesdn.html#pvesdn_zone_plugin_vxlan",
"subtitle" : "VXLAN Zones",
"title" : "Software-Defined Network"
},
"pvesr_schedule_time_format" : {
"link" : "/pve-docs/chapter-pvesr.html#pvesr_schedule_time_format",
"subtitle" : "Schedule Format",
"title" : "Storage Replication"
},
"pveum_authentication_realms" : {
"link" : "/pve-docs/chapter-pveum.html#pveum_authentication_realms",
"subtitle" : "Authentication Realms",
"title" : "User Management"
},
"pveum_configure_u2f" : {
"link" : "/pve-docs/chapter-pveum.html#pveum_configure_u2f",
"subtitle" : "Server Side U2F Configuration",
"title" : "User Management"
},
"pveum_configure_webauthn" : {
"link" : "/pve-docs/chapter-pveum.html#pveum_configure_webauthn",
"subtitle" : "Server Side Webauthn Configuration",
"title" : "User Management"
},
"pveum_groups" : {
"link" : "/pve-docs/chapter-pveum.html#pveum_groups",
"subtitle" : "Groups",
"title" : "User Management"
},
"pveum_ldap_sync" : {
"link" : "/pve-docs/chapter-pveum.html#pveum_ldap_sync",
"subtitle" : "Syncing LDAP-Based Realms",
"title" : "User Management"
},
"pveum_permission_management" : {
"link" : "/pve-docs/chapter-pveum.html#pveum_permission_management",
"subtitle" : "Permission Management",
"title" : "User Management"
},
"pveum_pools" : {
"link" : "/pve-docs/chapter-pveum.html#pveum_pools",
"subtitle" : "Pools",
"title" : "User Management"
},
"pveum_roles" : {
"link" : "/pve-docs/chapter-pveum.html#pveum_roles",
"subtitle" : "Roles",
"title" : "User Management"
},
"pveum_tokens" : {
"link" : "/pve-docs/chapter-pveum.html#pveum_tokens",
"subtitle" : "API Tokens",
"title" : "User Management"
},
"pveum_users" : {
"link" : "/pve-docs/chapter-pveum.html#pveum_users",
"subtitle" : "Users",
"title" : "User Management"
},
"qm_bios_and_uefi" : {
"link" : "/pve-docs/chapter-qm.html#qm_bios_and_uefi",
"subtitle" : "BIOS and UEFI",
"title" : "QEMU/KVM Virtual Machines"
},
"qm_bootorder" : {
"link" : "/pve-docs/chapter-qm.html#qm_bootorder",
"subtitle" : "Device Boot Order",
"title" : "QEMU/KVM Virtual Machines"
},
"qm_cloud_init" : {
"link" : "/pve-docs/chapter-qm.html#qm_cloud_init",
"title" : "Cloud-Init Support"
},
"qm_copy_and_clone" : {
"link" : "/pve-docs/chapter-qm.html#qm_copy_and_clone",
"subtitle" : "Copies and Clones",
"title" : "QEMU/KVM Virtual Machines"
},
"qm_cpu" : {
"link" : "/pve-docs/chapter-qm.html#qm_cpu",
"subtitle" : "CPU",
"title" : "QEMU/KVM Virtual Machines"
},
"qm_display" : {
"link" : "/pve-docs/chapter-qm.html#qm_display",
"subtitle" : "Display",
"title" : "QEMU/KVM Virtual Machines"
},
"qm_general_settings" : {
"link" : "/pve-docs/chapter-qm.html#qm_general_settings",
"subtitle" : "General Settings",
"title" : "QEMU/KVM Virtual Machines"
},
"qm_hard_disk" : {
"link" : "/pve-docs/chapter-qm.html#qm_hard_disk",
"subtitle" : "Hard Disk",
"title" : "QEMU/KVM Virtual Machines"
},
"qm_memory" : {
"link" : "/pve-docs/chapter-qm.html#qm_memory",
"subtitle" : "Memory",
"title" : "QEMU/KVM Virtual Machines"
},
"qm_migration" : {
"link" : "/pve-docs/chapter-qm.html#qm_migration",
"subtitle" : "Migration",
"title" : "QEMU/KVM Virtual Machines"
},
"qm_network_device" : {
"link" : "/pve-docs/chapter-qm.html#qm_network_device",
"subtitle" : "Network Device",
"title" : "QEMU/KVM Virtual Machines"
},
"qm_options" : {
"link" : "/pve-docs/chapter-qm.html#qm_options",
"subtitle" : "Options",
"title" : "QEMU/KVM Virtual Machines"
},
"qm_os_settings" : {
"link" : "/pve-docs/chapter-qm.html#qm_os_settings",
"subtitle" : "OS Settings",
"title" : "QEMU/KVM Virtual Machines"
},
"qm_pci_passthrough_vm_config" : {
"link" : "/pve-docs/chapter-qm.html#qm_pci_passthrough_vm_config",
"subtitle" : "VM Configuration",
"title" : "PCI(e) Passthrough"
},
"qm_qemu_agent" : {
"link" : "/pve-docs/chapter-qm.html#qm_qemu_agent",
"subtitle" : "QEMU Guest Agent",
"title" : "QEMU/KVM Virtual Machines"
},
"qm_spice_enhancements" : {
"link" : "/pve-docs/chapter-qm.html#qm_spice_enhancements",
"subtitle" : "SPICE Enhancements",
"title" : "QEMU/KVM Virtual Machines"
},
"qm_startup_and_shutdown" : {
"link" : "/pve-docs/chapter-qm.html#qm_startup_and_shutdown",
"subtitle" : "Automatic Start and Shutdown of Virtual Machines",
"title" : "QEMU/KVM Virtual Machines"
},
"qm_system_settings" : {
"link" : "/pve-docs/chapter-qm.html#qm_system_settings",
"subtitle" : "System Settings",
"title" : "QEMU/KVM Virtual Machines"
},
"qm_usb_passthrough" : {
"link" : "/pve-docs/chapter-qm.html#qm_usb_passthrough",
"subtitle" : "USB Passthrough",
"title" : "QEMU/KVM Virtual Machines"
},
"qm_virtio_rng" : {
"link" : "/pve-docs/chapter-qm.html#qm_virtio_rng",
"subtitle" : "VirtIO RNG",
"title" : "QEMU/KVM Virtual Machines"
},
"qm_virtual_machines_settings" : {
"link" : "/pve-docs/chapter-qm.html#qm_virtual_machines_settings",
"subtitle" : "Virtual Machines Settings",
"title" : "QEMU/KVM Virtual Machines"
},
"resource_mapping" : {
"link" : "/pve-docs/chapter-qm.html#resource_mapping",
"subtitle" : "Resource Mapping",
"title" : "QEMU/KVM Virtual Machines"
},
"storage_btrfs" : {
"link" : "/pve-docs/chapter-pvesm.html#storage_btrfs",
"title" : "BTRFS Backend"
},
"storage_cephfs" : {
"link" : "/pve-docs/chapter-pvesm.html#storage_cephfs",
"title" : "Ceph Filesystem (CephFS)"
},
"storage_cifs" : {
"link" : "/pve-docs/chapter-pvesm.html#storage_cifs",
"title" : "CIFS Backend"
},
"storage_directory" : {
"link" : "/pve-docs/chapter-pvesm.html#storage_directory",
"title" : "Directory Backend"
},
"storage_glusterfs" : {
"link" : "/pve-docs/chapter-pvesm.html#storage_glusterfs",
"title" : "GlusterFS Backend"
},
"storage_lvm" : {
"link" : "/pve-docs/chapter-pvesm.html#storage_lvm",
"title" : "LVM Backend"
},
"storage_lvmthin" : {
"link" : "/pve-docs/chapter-pvesm.html#storage_lvmthin",
"title" : "LVM thin Backend"
},
"storage_nfs" : {
"link" : "/pve-docs/chapter-pvesm.html#storage_nfs",
"title" : "NFS Backend"
},
"storage_open_iscsi" : {
"link" : "/pve-docs/chapter-pvesm.html#storage_open_iscsi",
"title" : "Open-iSCSI initiator"
},
"storage_pbs" : {
"link" : "/pve-docs/chapter-pvesm.html#storage_pbs",
"title" : "Proxmox Backup Server"
},
"storage_pbs_encryption" : {
"link" : "/pve-docs/chapter-pvesm.html#storage_pbs_encryption",
"subtitle" : "Encryption",
"title" : "Proxmox Backup Server"
},
"storage_zfspool" : {
"link" : "/pve-docs/chapter-pvesm.html#storage_zfspool",
"title" : "Local ZFS Pool Backend"
},
"sysadmin_certificate_management" : {
"link" : "/pve-docs/chapter-sysadmin.html#sysadmin_certificate_management",
"title" : "Certificate Management"
},
"sysadmin_certs_acme_plugins" : {
"link" : "/pve-docs/chapter-sysadmin.html#sysadmin_certs_acme_plugins",
"subtitle" : "ACME Plugins",
"title" : "Certificate Management"
},
"sysadmin_network_configuration" : {
"link" : "/pve-docs/chapter-sysadmin.html#sysadmin_network_configuration",
"title" : "Network Configuration"
},
"sysadmin_package_repositories" : {
"link" : "/pve-docs/chapter-sysadmin.html#sysadmin_package_repositories",
"title" : "Package Repositories"
},
"user-realms-ldap" : {
"link" : "/pve-docs/chapter-pveum.html#user-realms-ldap",
"subtitle" : "LDAP",
"title" : "User Management"
},
"user_mgmt" : {
"link" : "/pve-docs/chapter-pveum.html#user_mgmt",
"title" : "User Management"
},
"vzdump_retention" : {
"link" : "/pve-docs/chapter-vzdump.html#vzdump_retention",
"subtitle" : "Backup Retention",
"title" : "Backup and Restore"
}
};
// Some configuration values are complex strings - so we need parsers/generators for them.
Ext.define('PVE.Parser', {
statics: {
// this class only contains static functions
printACME: function(value) {
if (Ext.isArray(value.domains)) {
value.domains = value.domains.join(';');
}
return PVE.Parser.printPropertyString(value);
},
parseACME: function(value) {
if (!value) {
return {};
}
let res = {};
try {
value.split(',').forEach(property => {
let [k, v] = property.split('=', 2);
if (Ext.isDefined(v)) {
res[k] = v;
} else {
throw `Failed to parse key-value pair: ${property}`;
}
});
} catch (err) {
console.warn(err);
return undefined;
}
if (res.domains !== undefined) {
res.domains = res.domains.split(/;/);
}
return res;
},
parseBoolean: function(value, default_value) {
if (!Ext.isDefined(value)) {
return default_value;
}
value = value.toLowerCase();
return value === '1' ||
value === 'on' ||
value === 'yes' ||
value === 'true';
},
parsePropertyString: function(value, defaultKey) {
let res = {};
if (typeof value !== 'string' || value === '') {
return res;
}
try {
value.split(',').forEach(property => {
let [k, v] = property.split('=', 2);
if (Ext.isDefined(v)) {
res[k] = v;
} else if (Ext.isDefined(defaultKey)) {
if (Ext.isDefined(res[defaultKey])) {
throw 'defaultKey may be only defined once in propertyString';
}
res[defaultKey] = k; // k ist the value in this case
} else {
throw `Failed to parse key-value pair: ${property}`;
}
});
} catch (err) {
console.warn(err);
return undefined;
}
return res;
},
printPropertyString: function(data, defaultKey) {
var stringparts = [],
gotDefaultKeyVal = false,
defaultKeyVal;
Ext.Object.each(data, function(key, value) {
if (defaultKey !== undefined && key === defaultKey) {
gotDefaultKeyVal = true;
defaultKeyVal = value;
} else if (value !== '') {
stringparts.push(key + '=' + value);
}
});
stringparts = stringparts.sort();
if (gotDefaultKeyVal) {
stringparts.unshift(defaultKeyVal);
}
return stringparts.join(',');
},
parseQemuNetwork: function(key, value) {
if (!(key && value)) {
return undefined;
}
let res = {},
errors = false;
Ext.Array.each(value.split(','), function(p) {
if (!p || p.match(/^\s*$/)) {
return undefined; // continue
}
let match_res;
if ((match_res = p.match(/^(ne2k_pci|e1000|e1000-82540em|e1000-82544gc|e1000-82545em|vmxnet3|rtl8139|pcnet|virtio|ne2k_isa|i82551|i82557b|i82559er)(=([0-9a-f]{2}(:[0-9a-f]{2}){5}))?$/i)) !== null) {
res.model = match_res[1].toLowerCase();
if (match_res[3]) {
res.macaddr = match_res[3];
}
} else if ((match_res = p.match(/^bridge=(\S+)$/)) !== null) {
res.bridge = match_res[1];
} else if ((match_res = p.match(/^rate=(\d+(\.\d+)?)$/)) !== null) {
res.rate = match_res[1];
} else if ((match_res = p.match(/^tag=(\d+(\.\d+)?)$/)) !== null) {
res.tag = match_res[1];
} else if ((match_res = p.match(/^firewall=(\d+)$/)) !== null) {
res.firewall = match_res[1];
} else if ((match_res = p.match(/^link_down=(\d+)$/)) !== null) {
res.disconnect = match_res[1];
} else if ((match_res = p.match(/^queues=(\d+)$/)) !== null) {
res.queues = match_res[1];
} else if ((match_res = p.match(/^trunks=(\d+(?:-\d+)?(?:;\d+(?:-\d+)?)*)$/)) !== null) {
res.trunks = match_res[1];
} else if ((match_res = p.match(/^mtu=(\d+)$/)) !== null) {
res.mtu = match_res[1];
} else {
errors = true;
return false; // break
}
return undefined; // continue
});
if (errors || !res.model) {
return undefined;
}
return res;
},
printQemuNetwork: function(net) {
var netstr = net.model;
if (net.macaddr) {
netstr += "=" + net.macaddr;
}
if (net.bridge) {
netstr += ",bridge=" + net.bridge;
if (net.tag) {
netstr += ",tag=" + net.tag;
}
if (net.firewall) {
netstr += ",firewall=" + net.firewall;
}
}
if (net.rate) {
netstr += ",rate=" + net.rate;
}
if (net.queues) {
netstr += ",queues=" + net.queues;
}
if (net.disconnect) {
netstr += ",link_down=" + net.disconnect;
}
if (net.trunks) {
netstr += ",trunks=" + net.trunks;
}
if (net.mtu) {
netstr += ",mtu=" + net.mtu;
}
return netstr;
},
parseQemuDrive: function(key, value) {
if (!(key && value)) {
return undefined;
}
const [, bus, index] = key.match(/^([a-z]+)(\d+)$/);
if (!bus) {
return undefined;
}
let res = {
'interface': bus,
index,
};
var errors = false;
Ext.Array.each(value.split(','), function(p) {
if (!p || p.match(/^\s*$/)) {
return undefined; // continue
}
let match = p.match(/^([a-z_]+)=(\S+)$/);
if (!match) {
if (!p.match(/[=]/)) {
res.file = p;
return undefined; // continue
}
errors = true;
return false; // break
}
let [, k, v] = match;
if (k === 'volume') {
k = 'file';
}
if (Ext.isDefined(res[k])) {
errors = true;
return false; // break
}
if (k === 'cache' && v === 'off') {
v = 'none';
}
res[k] = v;
return undefined; // continue
});
if (errors || !res.file) {
return undefined;
}
return res;
},
printQemuDrive: function(drive) {
var drivestr = drive.file;
Ext.Object.each(drive, function(key, value) {
if (!Ext.isDefined(value) || key === 'file' ||
key === 'index' || key === 'interface') {
return; // continue
}
drivestr += ',' + key + '=' + value;
});
return drivestr;
},
parseIPConfig: function(key, value) {
if (!(key && value)) {
return undefined; // continue
}
let res = {};
try {
value.split(',').forEach(p => {
if (!p || p.match(/^\s*$/)) {
return; // continue
}
const match = p.match(/^(ip|gw|ip6|gw6)=(\S+)$/);
if (!match) {
throw `could not parse as IP config: ${p}`;
}
let [, k, v] = match;
res[k] = v;
});
} catch (err) {
console.warn(err);
return undefined; // continue
}
return res;
},
printIPConfig: function(cfg) {
return Object.entries(cfg)
.filter(([k, v]) => v && k.match(/^(ip|gw|ip6|gw6)$/))
.map(([k, v]) => `${k}=${v}`)
.join(',');
},
parseLxcNetwork: function(value) {
if (!value) {
return undefined;
}
let data = {};
value.split(',').forEach(p => {
if (!p || p.match(/^\s*$/)) {
return; // continue
}
let match_res = p.match(/^(bridge|hwaddr|mtu|name|ip|ip6|gw|gw6|tag|rate)=(\S+)$/);
if (match_res) {
data[match_res[1]] = match_res[2];
} else if ((match_res = p.match(/^firewall=(\d+)$/)) !== null) {
data.firewall = PVE.Parser.parseBoolean(match_res[1]);
} else if ((match_res = p.match(/^link_down=(\d+)$/)) !== null) {
data.link_down = PVE.Parser.parseBoolean(match_res[1]);
} else if (!p.match(/^type=\S+$/)) {
console.warn(`could not parse LXC network string ${p}`);
}
});
return data;
},
printLxcNetwork: function(config) {
let knownKeys = {
bridge: 1,
firewall: 1,
gw6: 1,
gw: 1,
hwaddr: 1,
ip6: 1,
ip: 1,
mtu: 1,
name: 1,
rate: 1,
tag: 1,
link_down: 1,
};
return Object.entries(config)
.filter(([k, v]) => v !== undefined && v !== '' && knownKeys[k])
.map(([k, v]) => `${k}=${v}`)
.join(',');
},
parseLxcMountPoint: function(value) {
if (!value) {
return undefined;
}
let res = {};
let errors = false;
Ext.Array.each(value.split(','), function(p) {
if (!p || p.match(/^\s*$/)) {
return undefined; // continue
}
let match = p.match(/^([a-z_]+)=(.+)$/);
if (!match) {
if (!p.match(/[=]/)) {
res.file = p;
return undefined; // continue
}
errors = true;
return false; // break
}
let [, k, v] = match;
if (k === 'volume') {
k = 'file';
}
if (Ext.isDefined(res[k])) {
errors = true;
return false; // break
}
res[k] = v;
return undefined;
});
if (errors || !res.file) {
return undefined;
}
const match = res.file.match(/^([a-z][a-z0-9\-_.]*[a-z0-9]):/i);
if (match) {
res.storage = match[1];
res.type = 'volume';
} else if (res.file.match(/^\/dev\//)) {
res.type = 'device';
} else {
res.type = 'bind';
}
return res;
},
printLxcMountPoint: function(mp) {
let drivestr = mp.file;
for (const [key, value] of Object.entries(mp)) {
if (!Ext.isDefined(value) || key === 'file' || key === 'type' || key === 'storage') {
continue;
}
drivestr += `,${key}=${value}`;
}
return drivestr;
},
parseStartup: function(value) {
if (value === undefined) {
return undefined;
}
let res = {};
try {
value.split(',').forEach(p => {
if (!p || p.match(/^\s*$/)) {
return; // continue
}
let match_res;
if ((match_res = p.match(/^(order)?=(\d+)$/)) !== null) {
res.order = match_res[2];
} else if ((match_res = p.match(/^up=(\d+)$/)) !== null) {
res.up = match_res[1];
} else if ((match_res = p.match(/^down=(\d+)$/)) !== null) {
res.down = match_res[1];
} else {
throw `could not parse startup config ${p}`;
}
});
} catch (err) {
console.warn(err);
return undefined;
}
return res;
},
printStartup: function(startup) {
let arr = [];
if (startup.order !== undefined && startup.order !== '') {
arr.push('order=' + startup.order);
}
if (startup.up !== undefined && startup.up !== '') {
arr.push('up=' + startup.up);
}
if (startup.down !== undefined && startup.down !== '') {
arr.push('down=' + startup.down);
}
return arr.join(',');
},
parseQemuSmbios1: function(value) {
let res = value.split(',').reduce((acc, currentValue) => {
const [k, v] = currentValue.split(/[=](.+)/);
acc[k] = v;
return acc;
}, {});
if (PVE.Parser.parseBoolean(res.base64, false)) {
for (const [k, v] of Object.entries(res)) {
if (k !== 'uuid') {
res[k] = Ext.util.Base64.decode(v);
}
}
}
return res;
},
printQemuSmbios1: function(data) {
let base64 = false;
let datastr = Object.entries(data)
.map(([key, value]) => {
if (value === '') {
return undefined;
}
if (key !== 'uuid') {
base64 = true; // smbios values can be arbitrary, so encode and mark config as such
value = Ext.util.Base64.encode(value);
}
return `${key}=${value}`;
})
.filter(v => v !== undefined)
.join(',');
if (base64) {
datastr += ',base64=1';
}
return datastr;
},
parseTfaConfig: function(value) {
let res = {};
value.split(',').forEach(p => {
const [k, v] = p.split('=', 2);
res[k] = v;
});
return res;
},
parseTfaType: function(value) {
let match;
if (!value || !value.length) {
return undefined;
} else if (value === 'x!oath') {
return 'totp';
} else if ((match = value.match(/^x!(.+)$/)) !== null) {
return match[1];
} else {
return 1;
}
},
parseQemuCpu: function(value) {
if (!value) {
return {};
}
let res = {};
let errors = false;
Ext.Array.each(value.split(','), function(p) {
if (!p || p.match(/^\s*$/)) {
return undefined; // continue
}
if (!p.match(/[=]/)) {
if (Ext.isDefined(res.cpu)) {
errors = true;
return false; // break
}
res.cputype = p;
return undefined; // continue
}
let match = p.match(/^([a-z_]+)=(\S+)$/);
if (!match || Ext.isDefined(res[match[1]])) {
errors = true;
return false; // break
}
let [, k, v] = match;
res[k] = v;
return undefined;
});
if (errors || !res.cputype) {
return undefined;
}
return res;
},
printQemuCpu: function(cpu) {
let cpustr = cpu.cputype;
let optstr = '';
Ext.Object.each(cpu, function(key, value) {
if (!Ext.isDefined(value) || key === 'cputype') {
return; // continue
}
optstr += ',' + key + '=' + value;
});
if (!cpustr) {
if (optstr) {
return 'kvm64' + optstr;
} else {
return undefined;
}
}
return cpustr + optstr;
},
parseSSHKey: function(key) {
// |--- options can have quotes--| type key comment
let keyre = /^(?:((?:[^\s"]|"(?:\\.|[^"\\])*")+)\s+)?(\S+)\s+(\S+)(?:\s+(.*))?$/;
let typere = /^(?:(?:sk-)?(?:ssh-(?:dss|rsa|ed25519)|ecdsa-sha2-nistp\d+)(?:@(?:[a-z0-9_-]+\.)+[a-z]{2,})?)$/;
let m = key.match(keyre);
if (!m || m.length < 3 || !m[2]) { // [2] is always either type or key
return null;
}
if (m[1] && m[1].match(typere)) {
return {
type: m[1],
key: m[2],
comment: m[3],
};
}
if (m[2].match(typere)) {
return {
options: m[1],
type: m[2],
key: m[3],
comment: m[4],
};
}
return null;
},
parseACMEPluginData: function(data) {
let res = {};
let extradata = [];
data.split('\n').forEach((line) => {
// capture everything after the first = as value
let [key, value] = line.split(/[=](.+)/);
if (value !== undefined) {
res[key] = value;
} else {
extradata.push(line);
}
});
return [res, extradata];
},
filterPropertyStringList: function(list, filterFn, defaultKey) {
return list.filter((entry) => filterFn(PVE.Parser.parsePropertyString(entry, defaultKey)));
},
},
});
/* This state provider keeps part of the state inside the browser history.
*
* We compress (shorten) url using dictionary based compression, i.e., we use
* column separated list instead of url encoded hash:
* #v\d* version/format
* := indicates string values
* :\d+ lookup value in dictionary hash
* #v1:=value1:5:=value2:=value3:...
*/
Ext.define('PVE.StateProvider', {
extend: 'Ext.state.LocalStorageProvider',
// private
setHV: function(name, newvalue, fireEvents) {
let me = this;
let changes = false;
let oldtext = Ext.encode(me.UIState[name]);
let newtext = Ext.encode(newvalue);
if (newtext !== oldtext) {
changes = true;
me.UIState[name] = newvalue;
if (fireEvents) {
me.fireEvent("statechange", me, name, { value: newvalue });
}
}
return changes;
},
// private
hslist: [
// order is important for notifications
// [ name, default ]
['view', 'server'],
['rid', 'root'],
['ltab', 'tasks'],
['nodetab', ''],
['storagetab', ''],
['sdntab', ''],
['pooltab', ''],
['kvmtab', ''],
['lxctab', ''],
['dctab', ''],
],
hprefix: 'v1',
compDict: {
tfa: 54,
sdn: 53,
cloudinit: 52,
replication: 51,
system: 50,
monitor: 49,
'ha-fencing': 48,
'ha-groups': 47,
'ha-resources': 46,
'ceph-log': 45,
'ceph-crushmap': 44,
'ceph-pools': 43,
'ceph-osdtree': 42,
'ceph-disklist': 41,
'ceph-monlist': 40,
'ceph-config': 39,
ceph: 38,
'firewall-fwlog': 37,
'firewall-options': 36,
'firewall-ipset': 35,
'firewall-aliases': 34,
'firewall-sg': 33,
firewall: 32,
apt: 31,
members: 30,
snapshot: 29,
ha: 28,
support: 27,
pools: 26,
syslog: 25,
ubc: 24,
initlog: 23,
openvz: 22,
backup: 21,
resources: 20,
content: 19,
root: 18,
domains: 17,
roles: 16,
groups: 15,
users: 14,
time: 13,
dns: 12,
network: 11,
services: 10,
options: 9,
console: 8,
hardware: 7,
permissions: 6,
summary: 5,
tasks: 4,
clog: 3,
storage: 2,
folder: 1,
server: 0,
},
decodeHToken: function(token) {
let me = this;
let state = {};
if (!token) {
me.hslist.forEach(([k, v]) => { state[k] = v; });
return state;
}
let [prefix, ...items] = token.split(':');
if (prefix !== me.hprefix) {
return me.decodeHToken();
}
Ext.Array.each(me.hslist, function(rec) {
let value = items.shift();
if (value) {
if (value[0] === '=') {
value = decodeURIComponent(value.slice(1));
}
for (const [key, hash] of Object.entries(me.compDict)) {
if (String(value) === String(hash)) {
value = key;
break;
}
}
}
state[rec[0]] = value;
});
return state;
},
encodeHToken: function(state) {
let me = this;
let ctoken = me.hprefix;
Ext.Array.each(me.hslist, function(rec) {
let value = state[rec[0]];
if (!Ext.isDefined(value)) {
value = rec[1];
}
value = encodeURIComponent(value);
if (!value) {
ctoken += ':';
} else if (Ext.isDefined(me.compDict[value])) {
ctoken += ":" + me.compDict[value];
} else {
ctoken += ":=" + value;
}
});
return ctoken;
},
constructor: function(config) {
let me = this;
me.callParent([config]);
me.UIState = me.decodeHToken(); // set default
let history_change_cb = function(token) {
if (!token) {
Ext.History.back();
return;
}
let newstate = me.decodeHToken(token);
Ext.Array.each(me.hslist, function(rec) {
if (typeof newstate[rec[0]] === "undefined") {
return;
}
me.setHV(rec[0], newstate[rec[0]], true);
});
};
let start_token = Ext.History.getToken();
if (start_token) {
history_change_cb(start_token);
} else {
let htext = me.encodeHToken(me.UIState);
Ext.History.add(htext);
}
Ext.History.on('change', history_change_cb);
},
get: function(name, defaultValue) {
let me = this;
let data;
if (typeof me.UIState[name] !== "undefined") {
data = { value: me.UIState[name] };
} else {
data = me.callParent(arguments);
if (!data && name === 'GuiCap') {
data = {
vms: {},
storage: {},
access: {},
nodes: {},
dc: {},
sdn: {},
};
}
}
return data;
},
clear: function(name) {
let me = this;
if (typeof me.UIState[name] !== "undefined") {
me.UIState[name] = null;
}
me.callParent(arguments);
},
set: function(name, value, fireevent) {
let me = this;
if (typeof me.UIState[name] !== "undefined") {
var newvalue = value ? value.value : null;
if (me.setHV(name, newvalue, fireevent)) {
let htext = me.encodeHToken(me.UIState);
Ext.History.add(htext);
}
} else {
me.callParent(arguments);
}
},
});
Ext.ns('PVE');
console.log("Starting Proxmox VE Manager");
Ext.Ajax.defaultHeaders = {
'Accept': 'application/json',
};
Ext.define('PVE.Utils', {
utilities: {
// this singleton contains miscellaneous utilities
toolkit: undefined, // (extjs|touch), set inside Toolkit.js
bus_match: /^(ide|sata|virtio|scsi)(\d+)$/,
log_severity_hash: {
0: "panic",
1: "alert",
2: "critical",
3: "error",
4: "warning",
5: "notice",
6: "info",
7: "debug",
},
support_level_hash: {
'c': gettext('Community'),
'b': gettext('Basic'),
's': gettext('Standard'),
'p': gettext('Premium'),
},
noSubKeyHtml: 'You do not have a valid subscription for this server. Please visit '
+''
+'www.proxmox.com to get a list of available options.',
getClusterSubscriptionLevel: async function() {
let { result } = await Proxmox.Async.api2({ url: '/cluster/status' });
let levelMap = Object.fromEntries(
result.data.filter(v => v.type === 'node').map(v => [v.name, v.level]),
);
return levelMap;
},
kvm_ostypes: {
'Linux': [
{ desc: '6.x - 2.6 Kernel', val: 'l26' },
{ desc: '2.4 Kernel', val: 'l24' },
],
'Microsoft Windows': [
{ desc: '11/2022', val: 'win11' },
{ desc: '10/2016/2019', val: 'win10' },
{ desc: '8.x/2012/2012r2', val: 'win8' },
{ desc: '7/2008r2', val: 'win7' },
{ desc: 'Vista/2008', val: 'w2k8' },
{ desc: 'XP/2003', val: 'wxp' },
{ desc: '2000', val: 'w2k' },
],
'Solaris Kernel': [
{ desc: '-', val: 'solaris' },
],
'Other': [
{ desc: '-', val: 'other' },
],
},
is_windows: function(ostype) {
for (let entry of PVE.Utils.kvm_ostypes['Microsoft Windows']) {
if (entry.val === ostype) {
return true;
}
}
return false;
},
get_health_icon: function(state, circle) {
if (circle === undefined) {
circle = false;
}
if (state === undefined) {
state = 'uknown';
}
var icon = 'faded fa-question';
switch (state) {
case 'good':
icon = 'good fa-check';
break;
case 'upgrade':
icon = 'warning fa-upload';
break;
case 'old':
icon = 'warning fa-refresh';
break;
case 'warning':
icon = 'warning fa-exclamation';
break;
case 'critical':
icon = 'critical fa-times';
break;
default: break;
}
if (circle) {
icon += '-circle';
}
return icon;
},
parse_ceph_version: function(service) {
if (service.ceph_version_short) {
return service.ceph_version_short;
}
if (service.ceph_version) {
var match = service.ceph_version.match(/version (\d+(\.\d+)*)/);
if (match) {
return match[1];
}
}
return undefined;
},
compare_ceph_versions: function(a, b) {
let avers = [];
let bvers = [];
if (a === b) {
return 0;
}
if (Ext.isArray(a)) {
avers = a.slice(); // copy array
} else {
avers = a.toString().split('.');
}
if (Ext.isArray(b)) {
bvers = b.slice(); // copy array
} else {
bvers = b.toString().split('.');
}
for (;;) {
let av = avers.shift();
let bv = bvers.shift();
if (av === undefined && bv === undefined) {
return 0;
} else if (av === undefined) {
return -1;
} else if (bv === undefined) {
return 1;
} else {
let diff = parseInt(av, 10) - parseInt(bv, 10);
if (diff !== 0) return diff;
// else we need to look at the next parts
}
}
},
get_ceph_icon_html: function(health, fw) {
var state = PVE.Utils.map_ceph_health[health];
var cls = PVE.Utils.get_health_icon(state);
if (fw) {
cls += ' fa-fw';
}
return "'+ value +'
';
}
} else if (rec.data.pending[key] !== undefined && rec.data.pending[key] !== null) {
if (rec.data.pending[key] === 'deleted') {
return ' ';
} else {
return rec.data.pending[key];
}
}
return value;
},
render_sdn_pending_state: function(rec, value) {
if (value === undefined || value === null) {
return ' ';
}
let icon = `' + icon + value + ' ';
}
let tip = gettext('Pending Changes') + ': '+ icon + value + ' ';
},
render_ceph_health: function(healthObj) {
var state = {
iconCls: PVE.Utils.get_health_icon(),
text: '',
};
if (!healthObj || !healthObj.status) {
return state;
}
var health = PVE.Utils.map_ceph_health[healthObj.status];
state.iconCls = PVE.Utils.get_health_icon(health, true);
state.text = healthObj.status;
return state;
},
render_zfs_health: function(value) {
if (typeof value === 'undefined') {
return "";
}
var iconCls = 'question-circle';
switch (value) {
case 'AVAIL':
case 'ONLINE':
iconCls = 'check-circle good';
break;
case 'REMOVED':
case 'DEGRADED':
iconCls = 'exclamation-circle warning';
break;
case 'UNAVAIL':
case 'FAULTED':
case 'OFFLINE':
iconCls = 'times-circle critical';
break;
default: //unknown
}
return '${icon} ${gettext('Encrypted')} `;
},
render_backup_verification: function(v, meta, record) {
let i = (cls, txt) => ` ${i(iconCls, txt)} `;
},
render_backup_status: function(value, meta, record) {
if (typeof value === 'undefined') {
return "";
}
let iconCls = 'check-circle good';
let text = gettext('Yes');
if (!PVE.Parser.parseBoolean(value.toString())) {
iconCls = 'times-circle critical';
text = gettext('No');
let reason = record.get('reason');
if (typeof reason !== 'undefined') {
if (reason in PVE.Utils.backup_reasons_table) {
reason = PVE.Utils.backup_reasons_table[record.get('reason')];
}
text = `${text} - ${reason}`;
}
}
return `' + value + ' ';
}
return value;
},
render_san: function(value) {
var names = [];
if (Ext.isArray(value)) {
value.forEach(function(val) {
if (!Ext.isNumber(val)) {
names.push(val);
}
});
return names.join('',
'{value}',
' ',
],
});
Ext.define('PVE.form.CephPoolSelector', {
extend: 'Ext.form.field.ComboBox',
alias: 'widget.pveCephPoolSelector',
allowBlank: false,
valueField: 'pool_name',
displayField: 'pool_name',
editable: false,
queryMode: 'local',
initComponent: function() {
var me = this;
if (!me.nodename) {
throw "no nodename given";
}
let onlyRBDPools = ({ data }) =>
!data?.application_metadata || !!data?.application_metadata?.rbd;
var store = Ext.create('Ext.data.Store', {
fields: ['name'],
sorters: 'name',
filters: [
onlyRBDPools,
],
proxy: {
type: 'proxmox',
url: '/api2/json/nodes/' + me.nodename + '/ceph/pool',
},
});
Ext.apply(me, {
store: store,
});
me.callParent();
store.load({
callback: function(rec, op, success) {
let filteredRec = rec.filter(onlyRBDPools);
if (success && filteredRec.length > 0) {
me.select(filteredRec[0]);
}
},
});
},
});
Ext.define('PVE.form.CephFSSelector', {
extend: 'Ext.form.field.ComboBox',
alias: 'widget.pveCephFSSelector',
allowBlank: false,
valueField: 'name',
displayField: 'name',
editable: false,
queryMode: 'local',
initComponent: function() {
var me = this;
if (!me.nodename) {
throw "no nodename given";
}
var store = Ext.create('Ext.data.Store', {
fields: ['name'],
sorters: 'name',
proxy: {
type: 'proxmox',
url: '/api2/json/nodes/' + me.nodename + '/ceph/fs',
},
});
Ext.apply(me, {
store: store,
});
me.callParent();
store.load({
callback: function(rec, op, success) {
if (success && rec.length > 0) {
me.select(rec[0]);
}
},
});
},
});
Ext.define('PVE.form.ComboBoxSetStoreNode', {
extend: 'Proxmox.form.ComboGrid',
config: {
apiBaseUrl: '/api2/json/nodes/',
apiSuffix: '',
},
showNodeSelector: false,
setNodeName: function(value) {
let me = this;
value ||= Proxmox.NodeName;
me.getStore().getProxy().setUrl(`${me.apiBaseUrl}${value}${me.apiSuffix}`);
me.clearValue();
},
nodeChange: function(_field, value) {
let me = this;
// disable autoSelect if there is already a selection or we have the picker open
if (me.getValue() || me.isExpanded) {
let autoSelect = me.autoSelect;
me.autoSelect = false;
me.store.on('afterload', function() {
me.autoSelect = autoSelect;
}, { single: true });
}
me.setNodeName(value);
me.fireEvent('nodechanged', value);
},
tbarMouseDown: function() {
this.topBarMousePress = true;
},
tbarMouseUp: function() {
let me = this;
delete this.topBarMousePress;
if (me.focusLeft) {
me.focus();
delete me.focusLeft;
}
},
// conditionally prevent the focusLeave handler to continue, preventing collapsing of the picker
onFocusLeave: function() {
let me = this;
me.focusLeft = true;
if (!me.topBarMousePress) {
me.callParent(arguments);
}
return undefined;
},
initComponent: function() {
let me = this;
if (me.showNodeSelector && !PVE.Utils.isStandaloneNode()) {
me.errorHeight = 140;
Ext.apply(me.listConfig ?? {}, {
tbar: {
xtype: 'toolbar',
minHeight: 40,
listeners: {
mousedown: me.tbarMouseDown,
mouseup: me.tbarMouseUp,
element: 'el',
scope: me,
},
items: [
{
xtype: "pveStorageScanNodeSelector",
autoSelect: false,
fieldLabel: gettext('Node to scan'),
listeners: {
change: (field, value) => me.nodeChange(field, value),
},
},
],
},
emptyText: me.listConfig?.emptyText ?? gettext('Nothing found'),
});
}
me.callParent();
},
});
Ext.define('PVE.form.ContentTypeSelector', {
extend: 'Proxmox.form.KVComboBox',
alias: ['widget.pveContentTypeSelector'],
cts: undefined,
initComponent: function() {
var me = this;
me.comboItems = [];
if (me.cts === undefined) {
me.cts = ['images', 'iso', 'vztmpl', 'backup', 'rootdir', 'snippets'];
}
Ext.Array.each(me.cts, function(ct) {
me.comboItems.push([ct, PVE.Utils.format_content_types(ct)]);
});
me.callParent();
},
});
Ext.define('PVE.form.ControllerSelector', {
extend: 'Ext.form.FieldContainer',
alias: 'widget.pveControllerSelector',
withVirtIO: true,
withUnused: false,
vmconfig: {}, // used to check for existing devices
setToFree: function(controllers, busField, deviceIDField) {
let me = this;
let freeId = PVE.Utils.nextFreeDisk(controllers, me.vmconfig);
if (freeId !== undefined) {
busField?.setValue(freeId.controller);
deviceIDField.setValue(freeId.id);
}
},
updateVMConfig: function(vmconfig) {
let me = this;
me.vmconfig = Ext.apply({}, vmconfig);
me.down('field[name=deviceid]').validate();
},
setVMConfig: function(vmconfig, autoSelect) {
let me = this;
me.vmconfig = Ext.apply({}, vmconfig);
let bussel = me.down('field[name=controller]');
let deviceid = me.down('field[name=deviceid]');
let clist;
if (autoSelect === 'cdrom') {
if (!Ext.isDefined(me.vmconfig.ide2)) {
bussel.setValue('ide');
deviceid.setValue(2);
return;
}
clist = ['ide', 'scsi', 'sata'];
} else {
// in most cases we want to add a disk to the same controller we previously used
clist = PVE.Utils.sortByPreviousUsage(me.vmconfig);
}
me.setToFree(clist, bussel, deviceid);
deviceid.validate();
},
getConfId: function() {
let me = this;
let controller = me.getComponent('controller').getValue() || 'ide';
let id = me.getComponent('deviceid').getValue() || 0;
return `${controller}${id}`;
},
initComponent: function() {
let me = this;
Ext.apply(me, {
fieldLabel: gettext('Bus/Device'),
layout: 'hbox',
defaults: {
hideLabel: true,
},
items: [
{
xtype: 'pveBusSelector',
name: 'controller',
itemId: 'controller',
value: PVE.qemu.OSDefaults.generic.busType,
withVirtIO: me.withVirtIO,
withUnused: me.withUnused,
allowBlank: false,
flex: 2,
listeners: {
change: function(t, value) {
if (!value) {
return;
}
let field = me.down('field[name=deviceid]');
me.setToFree([value], undefined, field);
field.setMaxValue(PVE.Utils.diskControllerMaxIDs[value] - 1);
field.validate();
},
},
},
{
xtype: 'proxmoxintegerfield',
name: 'deviceid',
itemId: 'deviceid',
minValue: 0,
maxValue: PVE.Utils.diskControllerMaxIDs.ide - 1,
value: '0',
flex: 1,
allowBlank: false,
validator: function(value) {
if (!me.rendered) {
return undefined;
}
let controller = me.down('field[name=controller]').getValue();
let confid = controller + value;
if (Ext.isDefined(me.vmconfig[confid])) {
return "This device is already in use.";
}
return true;
},
},
],
});
me.callParent();
if (me.selectFree) {
me.setVMConfig(me.vmconfig);
}
},
});
Ext.define('PVE.form.DayOfWeekSelector', {
extend: 'Proxmox.form.KVComboBox',
alias: ['widget.pveDayOfWeekSelector'],
comboItems: [],
initComponent: function() {
var me = this;
me.comboItems = [
['mon', Ext.util.Format.htmlDecode(Ext.Date.dayNames[1])],
['tue', Ext.util.Format.htmlDecode(Ext.Date.dayNames[2])],
['wed', Ext.util.Format.htmlDecode(Ext.Date.dayNames[3])],
['thu', Ext.util.Format.htmlDecode(Ext.Date.dayNames[4])],
['fri', Ext.util.Format.htmlDecode(Ext.Date.dayNames[5])],
['sat', Ext.util.Format.htmlDecode(Ext.Date.dayNames[6])],
['sun', Ext.util.Format.htmlDecode(Ext.Date.dayNames[0])],
];
this.callParent();
},
});
Ext.define('PVE.form.DiskFormatSelector', {
extend: 'Proxmox.form.KVComboBox',
alias: 'widget.pveDiskFormatSelector',
comboItems: [
['raw', gettext('Raw disk image') + ' (raw)'],
['qcow2', gettext('QEMU image format') + ' (qcow2)'],
['vmdk', gettext('VMware image format') + ' (vmdk)'],
],
});
Ext.define('PVE.form.DiskStorageSelector', {
extend: 'Ext.container.Container',
alias: 'widget.pveDiskStorageSelector',
layout: 'fit',
defaults: {
margin: '0 0 5 0',
},
// the fieldLabel for the storageselector
storageLabel: gettext('Storage'),
// the content to show (e.g., images or rootdir)
storageContent: undefined,
// if true, selects the first available storage
autoSelect: false,
allowBlank: false,
emptyText: '',
// hides the selection field
// this is always hidden on creation,
// and only shown when the storage needs a selection and
// hideSelection is not true
hideSelection: undefined,
// hides the size field (e.g, for the efi disk dialog)
hideSize: false,
// hides the format field (e.g. for TPM state)
hideFormat: false,
// sets the initial size value
// string because else we get a type confusion
defaultSize: '32',
changeStorage: function(f, value) {
var me = this;
var formatsel = me.getComponent('diskformat');
var hdfilesel = me.getComponent('hdimage');
var hdsizesel = me.getComponent('disksize');
// initial store load, and reset/deletion of the storage
if (!value) {
hdfilesel.setDisabled(true);
hdfilesel.setVisible(false);
formatsel.setDisabled(true);
return;
}
var rec = f.store.getById(value);
// if the storage is not defined, or valid,
// we cannot know what to enable/disable
if (!rec) {
return;
}
let validFormats = {};
let selectFormat = 'raw';
if (rec.data.format) {
validFormats = rec.data.format[0]; // 0 is the formats, 1 the default in the backend
delete validFormats.subvol; // we never need subvol in the gui
if (validFormats.qcow2) {
selectFormat = 'qcow2';
} else if (validFormats.raw) {
selectFormat = 'raw';
} else {
selectFormat = rec.data.format[1];
}
}
var select = !!rec.data.select_existing && !me.hideSelection;
formatsel.setDisabled(me.hideFormat || Ext.Object.getSize(validFormats) <= 1);
formatsel.setValue(selectFormat);
hdfilesel.setDisabled(!select);
hdfilesel.setVisible(select);
if (select) {
hdfilesel.setStorage(value);
}
hdsizesel.setDisabled(select || me.hideSize);
hdsizesel.setVisible(!select && !me.hideSize);
},
setNodename: function(nodename) {
var me = this;
var hdstorage = me.getComponent('hdstorage');
var hdfilesel = me.getComponent('hdimage');
hdstorage.setNodename(nodename);
hdfilesel.setNodename(nodename);
},
setDisabled: function(value) {
var me = this;
var hdstorage = me.getComponent('hdstorage');
// reset on disable
if (value) {
hdstorage.setValue();
}
hdstorage.setDisabled(value);
// disabling does not always fire this event and we do not need
// the value of the validity
hdstorage.fireEvent('validitychange');
},
initComponent: function() {
var me = this;
me.items = [
{
xtype: 'pveStorageSelector',
itemId: 'hdstorage',
name: 'hdstorage',
fieldLabel: me.storageLabel,
nodename: me.nodename,
storageContent: me.storageContent,
disabled: me.disabled,
autoSelect: me.autoSelect,
allowBlank: me.allowBlank,
emptyText: me.emptyText,
listeners: {
change: {
fn: me.changeStorage,
scope: me,
},
},
},
{
xtype: 'pveFileSelector',
name: 'hdimage',
itemId: 'hdimage',
fieldLabel: gettext('Disk image'),
nodename: me.nodename,
disabled: true,
hidden: true,
},
{
xtype: 'numberfield',
itemId: 'disksize',
name: 'disksize',
fieldLabel: `${gettext('Disk size')} (${gettext('GiB')})`,
hidden: me.hideSize,
disabled: me.hideSize,
minValue: 0.001,
maxValue: 128*1024,
decimalPrecision: 3,
value: me.defaultSize,
allowBlank: false,
},
{
xtype: 'pveDiskFormatSelector',
itemId: 'diskformat',
name: 'diskformat',
fieldLabel: gettext('Format'),
nodename: me.nodename,
disabled: true,
hidden: me.hideFormat || me.storageContent === 'rootdir',
value: 'qcow2',
allowBlank: false,
},
];
// use it to disable the children but not ourself
me.disabled = false;
me.callParent();
},
});
Ext.define('PVE.form.FileSelector', {
extend: 'Proxmox.form.ComboGrid',
alias: 'widget.pveFileSelector',
editable: true,
anyMatch: true,
forceSelection: true,
listeners: {
afterrender: function() {
var me = this;
if (!me.disabled) {
me.setStorage(me.storage, me.nodename);
}
},
},
setStorage: function(storage, nodename) {
var me = this;
var change = false;
if (storage && me.storage !== storage) {
me.storage = storage;
change = true;
}
if (nodename && me.nodename !== nodename) {
me.nodename = nodename;
change = true;
}
if (!(me.storage && me.nodename && change)) {
return;
}
var url = '/api2/json/nodes/' + me.nodename + '/storage/' + me.storage + '/content';
if (me.storageContent) {
url += '?content=' + me.storageContent;
}
me.store.setProxy({
type: 'proxmox',
url: url,
});
me.store.removeAll();
me.store.load();
},
setNodename: function(nodename) {
this.setStorage(undefined, nodename);
},
store: {
model: 'pve-storage-content',
},
allowBlank: false,
autoSelect: false,
valueField: 'volid',
displayField: 'text',
listConfig: {
width: 600,
columns: [
{
header: gettext('Name'),
dataIndex: 'text',
hideable: false,
flex: 1,
},
{
header: gettext('Format'),
width: 60,
dataIndex: 'format',
},
{
header: gettext('Size'),
width: 100,
dataIndex: 'size',
renderer: Proxmox.Utils.format_size,
},
],
},
});
Ext.define('PVE.form.FirewallPolicySelector', {
extend: 'Proxmox.form.KVComboBox',
alias: ['widget.pveFirewallPolicySelector'],
comboItems: [
['ACCEPT', 'ACCEPT'],
['REJECT', 'REJECT'],
['DROP', 'DROP'],
],
});
/*
* This is a global search field it loads the /cluster/resources on focus and displays the
* result in a floating grid. Filtering and sorting is done in the customFilter function
*
* Accepts key up/down and enter for input, and it opens to CTRL+SHIFT+F and CTRL+SPACE
*/
Ext.define('PVE.form.GlobalSearchField', {
extend: 'Ext.form.field.Text',
alias: 'widget.pveGlobalSearchField',
emptyText: gettext('Search'),
enableKeyEvents: true,
selectOnFocus: true,
padding: '0 5 0 5',
grid: {
xtype: 'gridpanel',
userCls: 'proxmox-tags-full',
focusOnToFront: false,
floating: true,
emptyText: Proxmox.Utils.noneText,
width: 600,
height: 400,
scrollable: {
xtype: 'scroller',
y: true,
x: true,
},
store: {
model: 'PVEResources',
proxy: {
type: 'proxmox',
url: '/api2/extjs/cluster/resources',
},
},
plugins: {
ptype: 'bufferedrenderer',
trailingBufferZone: 20,
leadingBufferZone: 20,
},
hideMe: function() {
var me = this;
if (typeof me.ctxMenu !== 'undefined' && me.ctxMenu.isVisible()) {
return;
}
me.hasFocus = false;
if (!me.textfield.hasFocus) {
me.hide();
}
},
setFocus: function() {
var me = this;
me.hasFocus = true;
},
listeners: {
rowclick: function(grid, record) {
var me = this;
me.textfield.selectAndHide(record.id);
},
itemcontextmenu: function(v, record, item, index, event) {
var me = this;
me.ctxMenu = PVE.Utils.createCmdMenu(v, record, item, index, event);
},
focusleave: 'hideMe',
focusenter: 'setFocus',
},
columns: [
{
text: gettext('Type'),
dataIndex: 'type',
width: 100,
renderer: PVE.Utils.render_resource_type,
},
{
text: gettext('Description'),
flex: 1,
dataIndex: 'text',
renderer: function(value, mD, rec) {
let overrides = PVE.UIOptions.tagOverrides;
let tags = PVE.Utils.renderTags(rec.data.tags, overrides);
return `${value}${tags}`;
},
},
{
text: gettext('Node'),
dataIndex: 'node',
},
{
text: gettext('Pool'),
dataIndex: 'pool',
},
],
},
customFilter: function(item) {
let me = this;
if (me.filterVal === '') {
item.data.relevance = 0;
return true;
}
// different types have different fields to search, e.g., a node will never have a pool
const fieldMap = {
'pool': ['type', 'pool', 'text'],
'node': ['type', 'node', 'text'],
'storage': ['type', 'pool', 'node', 'storage'],
'default': ['name', 'type', 'node', 'pool', 'vmid'],
};
let fields = fieldMap[item.data.type] || fieldMap.default;
let fieldArr = fields.map(field => item.data[field]?.toString().toLowerCase());
if (item.data.tags) {
let tags = item.data.tags.split(/[;, ]/);
fieldArr.push(...tags);
}
let filterWords = me.filterVal.split(/\s+/);
// all text is case insensitive and each split-out word is searched for separately.
// a row gets 1 point for every partial match, and and additional point for every exact match
let match = 0;
for (let fieldValue of fieldArr) {
if (fieldValue === undefined || fieldValue === "") {
continue;
}
for (let filterWord of filterWords) {
if (fieldValue.indexOf(filterWord) !== -1) {
match++; // partial match
if (fieldValue === filterWord) {
match++; // exact match is worth more
}
}
}
}
item.data.relevance = match; // set the row's virtual 'relevance' value for ordering
return match > 0;
},
updateFilter: function(field, newValue, oldValue) {
let me = this;
// parse input and filter store, show grid
me.grid.store.filterVal = newValue.toLowerCase().trim();
me.grid.store.clearFilter(true);
me.grid.store.filterBy(me.customFilter);
me.grid.getSelectionModel().select(0);
},
selectAndHide: function(id) {
var me = this;
me.tree.selectById(id);
me.grid.hide();
me.setValue('');
me.blur();
},
onKey: function(field, e) {
var me = this;
var key = e.getKey();
switch (key) {
case Ext.event.Event.ENTER:
// go to first entry if there is one
if (me.grid.store.getCount() > 0) {
me.selectAndHide(me.grid.getSelection()[0].data.id);
}
break;
case Ext.event.Event.UP:
me.grid.getSelectionModel().selectPrevious();
break;
case Ext.event.Event.DOWN:
me.grid.getSelectionModel().selectNext();
break;
case Ext.event.Event.ESC:
me.grid.hide();
me.blur();
break;
}
},
loadValues: function(field) {
let me = this;
me.hasFocus = true;
me.grid.textfield = me;
me.grid.store.load();
me.grid.showBy(me, 'tl-bl');
},
hideGrid: function() {
let me = this;
me.hasFocus = false;
if (!me.grid.hasFocus) {
me.grid.hide();
}
},
listeners: {
change: {
fn: 'updateFilter',
buffer: 250,
},
specialkey: 'onKey',
focusenter: 'loadValues',
focusleave: {
fn: 'hideGrid',
delay: 100,
},
},
toggleFocus: function() {
let me = this;
if (!me.hasFocus) {
me.focus();
} else {
me.blur();
}
},
initComponent: function() {
let me = this;
if (!me.tree) {
throw "no tree given";
}
me.grid = Ext.create(me.grid);
me.callParent();
// bind CTRL + SHIFT + F and CTRL + SPACE to open/close the search
me.keymap = new Ext.KeyMap({
target: Ext.get(document),
binding: [{
key: 'F',
ctrl: true,
shift: true,
fn: me.toggleFocus,
scope: me,
}, {
key: ' ',
ctrl: true,
fn: me.toggleFocus,
scope: me,
}],
});
// always select first item and sort by relevance after load
me.mon(me.grid.store, 'load', function() {
me.grid.getSelectionModel().select(0);
me.grid.store.sort({
property: 'relevance',
direction: 'DESC',
});
});
},
});
Ext.define('pve-groups', {
extend: 'Ext.data.Model',
fields: ['groupid', 'comment', 'users'],
proxy: {
type: 'proxmox',
url: "/api2/json/access/groups",
},
idProperty: 'groupid',
});
Ext.define('PVE.form.GroupSelector', {
extend: 'Proxmox.form.ComboGrid',
xtype: 'pveGroupSelector',
allowBlank: false,
autoSelect: false,
valueField: 'groupid',
displayField: 'groupid',
listConfig: {
columns: [
{
header: gettext('Group'),
sortable: true,
dataIndex: 'groupid',
flex: 1,
},
{
header: gettext('Comment'),
sortable: false,
dataIndex: 'comment',
renderer: Ext.String.htmlEncode,
flex: 1,
},
{
header: gettext('Users'),
sortable: false,
dataIndex: 'users',
renderer: Ext.String.htmlEncode,
flex: 1,
},
],
},
initComponent: function() {
var me = this;
var store = new Ext.data.Store({
model: 'pve-groups',
sorters: [{
property: 'groupid',
}],
});
Ext.apply(me, {
store: store,
});
me.callParent();
store.load();
},
});
Ext.define('PVE.form.GuestIDSelector', {
extend: 'Ext.form.field.Number',
alias: 'widget.pveGuestIDSelector',
allowBlank: false,
minValue: 100,
maxValue: 999999999,
validateExists: undefined,
loadNextFreeID: false,
guestType: undefined,
validator: function(value) {
var me = this;
if (!Ext.isNumeric(value) ||
value < me.minValue ||
value > me.maxValue) {
// check is done by ExtJS
return true;
}
if (me.validateExists === true && !me.exists) {
return me.unknownID;
}
if (me.validateExists === false && me.exists) {
return me.inUseID;
}
return true;
},
initComponent: function() {
var me = this;
var label = '{0} ID';
var unknownID = gettext('This {0} ID does not exist');
var inUseID = gettext('This {0} ID is already in use');
var type = 'CT/VM';
if (me.guestType === 'lxc') {
type = 'CT';
} else if (me.guestType === 'qemu') {
type = 'VM';
}
me.label = Ext.String.format(label, type);
me.unknownID = Ext.String.format(unknownID, type);
me.inUseID = Ext.String.format(inUseID, type);
Ext.apply(me, {
fieldLabel: me.label,
listeners: {
'change': function(field, newValue, oldValue) {
if (!Ext.isDefined(me.validateExists)) {
return;
}
Proxmox.Utils.API2Request({
params: { vmid: newValue },
url: '/cluster/nextid',
method: 'GET',
success: function(response, opts) {
me.exists = false;
me.validate();
},
failure: function(response, opts) {
me.exists = true;
me.validate();
},
});
},
},
});
me.callParent();
if (me.loadNextFreeID) {
Proxmox.Utils.API2Request({
url: '/cluster/nextid',
method: 'GET',
success: function(response, opts) {
me.setRawValue(response.result.data);
},
});
}
},
});
Ext.define('PVE.form.hashAlgorithmSelector', {
extend: 'Proxmox.form.KVComboBox',
alias: ['widget.pveHashAlgorithmSelector'],
config: {
deleteEmpty: false,
},
comboItems: [
['__default__', 'None'],
['md5', 'MD5'],
['sha1', 'SHA-1'],
['sha224', 'SHA-224'],
['sha256', 'SHA-256'],
['sha384', 'SHA-384'],
['sha512', 'SHA-512'],
],
});
Ext.define('PVE.form.HotplugFeatureSelector', {
extend: 'Ext.form.CheckboxGroup',
alias: 'widget.pveHotplugFeatureSelector',
columns: 1,
vertical: true,
defaults: {
name: 'hotplugCbGroup',
submitValue: false,
},
items: [
{
boxLabel: gettext('Disk'),
inputValue: 'disk',
checked: true,
},
{
boxLabel: gettext('Network'),
inputValue: 'network',
checked: true,
},
{
boxLabel: 'USB',
inputValue: 'usb',
checked: true,
},
{
boxLabel: gettext('Memory'),
inputValue: 'memory',
},
{
boxLabel: gettext('CPU'),
inputValue: 'cpu',
},
],
setValue: function(value) {
var me = this;
var newVal = [];
if (value === '1') {
newVal = ['disk', 'network', 'usb'];
} else if (value !== '0') {
newVal = value.split(',');
}
me.callParent([{ hotplugCbGroup: newVal }]);
},
// override framework function to
// assemble the hotplug value
getSubmitData: function() {
var me = this,
boxes = me.getBoxes(),
data = [];
Ext.Array.forEach(boxes, function(box) {
if (box.getValue()) {
data.push(box.inputValue);
}
});
/* because above is hotplug an array */
if (data.length === 0) {
return { 'hotplug': '0' };
} else {
return { 'hotplug': data.join(',') };
}
},
});
Ext.define('PVE.form.IPProtocolSelector', {
extend: 'Proxmox.form.ComboGrid',
alias: ['widget.pveIPProtocolSelector'],
valueField: 'p',
displayField: 'p',
listConfig: {
columns: [
{
header: gettext('Protocol'),
dataIndex: 'p',
hideable: false,
sortable: false,
width: 100,
},
{
header: gettext('Number'),
dataIndex: 'n',
hideable: false,
sortable: false,
width: 50,
},
{
header: gettext('Description'),
dataIndex: 'd',
hideable: false,
sortable: false,
flex: 1,
},
],
},
store: {
fields: ['p', 'd', 'n'],
data: [
{ p: 'tcp', n: 6, d: 'Transmission Control Protocol' },
{ p: 'udp', n: 17, d: 'User Datagram Protocol' },
{ p: 'icmp', n: 1, d: 'Internet Control Message Protocol' },
{ p: 'igmp', n: 2, d: 'Internet Group Management' },
{ p: 'ggp', n: 3, d: 'gateway-gateway protocol' },
{ p: 'ipencap', n: 4, d: 'IP encapsulated in IP' },
{ p: 'st', n: 5, d: 'ST datagram mode' },
{ p: 'egp', n: 8, d: 'exterior gateway protocol' },
{ p: 'igp', n: 9, d: 'any private interior gateway (Cisco)' },
{ p: 'pup', n: 12, d: 'PARC universal packet protocol' },
{ p: 'hmp', n: 20, d: 'host monitoring protocol' },
{ p: 'xns-idp', n: 22, d: 'Xerox NS IDP' },
{ p: 'rdp', n: 27, d: '"reliable datagram" protocol' },
{ p: 'iso-tp4', n: 29, d: 'ISO Transport Protocol class 4 [RFC905]' },
{ p: 'dccp', n: 33, d: 'Datagram Congestion Control Prot. [RFC4340]' },
{ p: 'xtp', n: 36, d: 'Xpress Transfer Protocol' },
{ p: 'ddp', n: 37, d: 'Datagram Delivery Protocol' },
{ p: 'idpr-cmtp', n: 38, d: 'IDPR Control Message Transport' },
{ p: 'ipv6', n: 41, d: 'Internet Protocol, version 6' },
{ p: 'ipv6-route', n: 43, d: 'Routing Header for IPv6' },
{ p: 'ipv6-frag', n: 44, d: 'Fragment Header for IPv6' },
{ p: 'idrp', n: 45, d: 'Inter-Domain Routing Protocol' },
{ p: 'rsvp', n: 46, d: 'Reservation Protocol' },
{ p: 'gre', n: 47, d: 'General Routing Encapsulation' },
{ p: 'esp', n: 50, d: 'Encap Security Payload [RFC2406]' },
{ p: 'ah', n: 51, d: 'Authentication Header [RFC2402]' },
{ p: 'skip', n: 57, d: 'SKIP' },
{ p: 'ipv6-icmp', n: 58, d: 'ICMP for IPv6' },
{ p: 'ipv6-nonxt', n: 59, d: 'No Next Header for IPv6' },
{ p: 'ipv6-opts', n: 60, d: 'Destination Options for IPv6' },
{ p: 'vmtp', n: 81, d: 'Versatile Message Transport' },
{ p: 'eigrp', n: 88, d: 'Enhanced Interior Routing Protocol (Cisco)' },
{ p: 'ospf', n: 89, d: 'Open Shortest Path First IGP' },
{ p: 'ax.25', n: 93, d: 'AX.25 frames' },
{ p: 'ipip', n: 94, d: 'IP-within-IP Encapsulation Protocol' },
{ p: 'etherip', n: 97, d: 'Ethernet-within-IP Encapsulation [RFC3378]' },
{ p: 'encap', n: 98, d: 'Yet Another IP encapsulation [RFC1241]' },
{ p: 'pim', n: 103, d: 'Protocol Independent Multicast' },
{ p: 'ipcomp', n: 108, d: 'IP Payload Compression Protocol' },
{ p: 'vrrp', n: 112, d: 'Virtual Router Redundancy Protocol [RFC5798]' },
{ p: 'l2tp', n: 115, d: 'Layer Two Tunneling Protocol [RFC2661]' },
{ p: 'isis', n: 124, d: 'IS-IS over IPv4' },
{ p: 'sctp', n: 132, d: 'Stream Control Transmission Protocol' },
{ p: 'fc', n: 133, d: 'Fibre Channel' },
{ p: 'mobility-header', n: 135, d: 'Mobility Support for IPv6 [RFC3775]' },
{ p: 'udplite', n: 136, d: 'UDP-Lite [RFC3828]' },
{ p: 'mpls-in-ip', n: 137, d: 'MPLS-in-IP [RFC4023]' },
{ p: 'hip', n: 139, d: 'Host Identity Protocol' },
{ p: 'shim6', n: 140, d: 'Shim6 Protocol [RFC5533]' },
{ p: 'wesp', n: 141, d: 'Wrapped Encapsulating Security Payload' },
{ p: 'rohc', n: 142, d: 'Robust Header Compression' },
],
},
});
Ext.define('PVE.form.IPRefSelector', {
extend: 'Proxmox.form.ComboGrid',
alias: ['widget.pveIPRefSelector'],
base_url: undefined,
preferredValue: '', // hack: else Form sets dirty flag?
ref_type: undefined, // undefined = any [undefined, 'ipset' or 'alias']
valueField: 'scopedref',
displayField: 'ref',
notFoundIsValid: true,
initComponent: function() {
var me = this;
if (!me.base_url) {
throw "no base_url specified";
}
var url = "/api2/json" + me.base_url;
if (me.ref_type) {
url += "?type=" + me.ref_type;
}
var store = Ext.create('Ext.data.Store', {
autoLoad: true,
fields: [
'type',
'name',
'ref',
'comment',
'scope',
{
name: 'scopedref',
calculate: function(v) {
if (v.type === 'alias') {
return `${v.scope}/${v.name}`;
} else {
return `+${v.scope}/${v.name}`;
}
},
},
],
idProperty: 'ref',
proxy: {
type: 'proxmox',
url: url,
},
sorters: {
property: 'ref',
direction: 'ASC',
},
});
var disable_query_for_ips = function(f, value) {
if (value === null ||
value.match(/^\d/)) { // IP address starts with \d
f.queryDelay = 9999999999; // hack: disable with long delay
} else {
f.queryDelay = 10;
}
};
var columns = [];
if (!me.ref_type) {
columns.push({
header: gettext('Type'),
dataIndex: 'type',
hideable: false,
width: 60,
});
}
columns.push(
{
header: gettext('Name'),
dataIndex: 'ref',
hideable: false,
width: 140,
},
{
header: gettext('Scope'),
dataIndex: 'scope',
hideable: false,
width: 140,
renderer: function(value) {
return value === 'dc' ? gettext("Datacenter") : gettext("Guest");
},
},
{
header: gettext('Comment'),
dataIndex: 'comment',
renderer: Ext.String.htmlEncode,
minWidth: 60,
flex: 1,
},
);
Ext.apply(me, {
store: store,
listConfig: {
columns: columns,
width: 500,
},
});
me.on('change', disable_query_for_ips);
me.callParent();
},
});
Ext.define('PVE.form.MDevSelector', {
extend: 'Proxmox.form.ComboGrid',
xtype: 'pveMDevSelector',
store: {
fields: ['type', 'available', 'description'],
filterOnLoad: true,
sorters: [
{
property: 'type',
direction: 'ASC',
},
],
},
autoSelect: false,
valueField: 'type',
displayField: 'type',
listConfig: {
width: 550,
columns: [
{
header: gettext('Type'),
dataIndex: 'type',
renderer: function(value, md, rec) {
if (rec.data.name !== undefined) {
return `${rec.data.name} (${value})`;
}
return value;
},
flex: 1,
},
{
header: gettext('Avail'),
dataIndex: 'available',
width: 60,
},
{
header: gettext('Description'),
dataIndex: 'description',
flex: 1,
cellWrap: true,
renderer: function(value) {
if (!value) {
return '';
}
return value.split('\n').join('{tag} ',
'tabindex="{tabIndex}" ',
'>',
],
createFileInput: function(isTemporary) {
var me = this,
fileInputEl, listeners;
fileInputEl = me.fileInputEl = me.el.createChild({
name: me.inputName || me.id,
multiple: true, // pmx: added multiple option
id: !isTemporary ? me.id + '-fileInputEl' : undefined,
cls: me.inputCls + (me.getInherited().rtl ? ' ' + Ext.baseCSSPrefix + 'rtl' : ''),
tag: 'input',
type: 'file',
size: 1,
unselectable: 'on',
}, me.afterInputGuard); // Nothing special happens outside of IE/Edge
// This is our focusEl
fileInputEl.dom.setAttribute('data-componentid', me.id);
if (me.tabIndex !== null) {
me.setTabIndex(me.tabIndex);
}
if (me.accept) {
fileInputEl.dom.setAttribute('accept', me.accept);
}
// We place focus and blur listeners on fileInputEl to activate Button's
// focus and blur style treatment
listeners = {
scope: me,
change: me.fireChange,
mousedown: me.handlePrompt,
keydown: me.handlePrompt,
focus: me.onFileFocus,
blur: me.onFileBlur,
};
if (me.useTabGuards) {
listeners.keydown = me.onFileInputKeydown;
}
fileInputEl.on(listeners);
},
});
Ext.define('PVE.form.TagFieldSet', {
extend: 'Ext.form.FieldSet',
alias: 'widget.pveTagFieldSet',
mixins: ['Ext.form.field.Field'],
title: gettext('Tags'),
padding: '0 5 5 5',
getValue: function() {
let me = this;
let tags = me.down('pveTagEditContainer').getTags().filter(t => t !== '');
return tags.join(';');
},
setValue: function(value) {
let me = this;
value ??= [];
if (!Ext.isArray(value)) {
value = value.split(/[;, ]/).filter(t => t !== '');
}
me.down('pveTagEditContainer').loadTags(value.join(';'));
},
getErrors: function(value) {
value ??= [];
if (!Ext.isArray(value)) {
value = value.split(/[;, ]/).filter(t => t !== '');
}
if (value.some(t => !t.match(PVE.Utils.tagCharRegex))) {
return [gettext("Tags contain invalid characters.")];
}
return [];
},
getSubmitData: function() {
let me = this;
let value = me.getValue();
if (me.disabled || !me.submitValue || value === '') {
return null;
}
let data = {};
data[me.getName()] = value;
return data;
},
layout: 'fit',
items: [
{
xtype: 'pveTagEditContainer',
userCls: 'proxmox-tags-full proxmox-tag-fieldset',
editOnly: true,
allowBlank: true,
layout: 'column',
scrollable: true,
},
],
initComponent: function() {
let me = this;
me.callParent();
me.initField();
},
});
Ext.define('PVE.form.IsoSelector', {
extend: 'Ext.container.Container',
alias: 'widget.pveIsoSelector',
mixins: [
'Ext.form.field.Field',
'Proxmox.Mixin.CBind',
],
layout: {
type: 'vbox',
align: 'stretch',
},
nodename: undefined,
insideWizard: false,
cbindData: function() {
let me = this;
return {
nodename: me.nodename,
insideWizard: me.insideWizard,
};
},
getValue: function() {
return this.lookup('file').getValue();
},
setValue: function(value) {
let me = this;
if (!value) {
me.lookup('file').reset();
return;
}
var match = value.match(/^([^:]+):/);
if (match) {
me.lookup('storage').setValue(match[1]);
me.lookup('file').setValue(value);
}
},
getErrors: function() {
let me = this;
me.lookup('storage').validate();
let file = me.lookup('file');
file.validate();
let value = file.getValue();
if (!value || !value.length) {
return [""]; // for validation
}
return [];
},
setNodename: function(nodename) {
let me = this;
me.lookup('storage').setNodename(nodename);
me.lookup('file').setStorage(undefined, nodename);
},
setDisabled: function(disabled) {
let me = this;
me.lookup('storage').setDisabled(disabled);
me.lookup('file').setDisabled(disabled);
me.callParent();
},
referenceHolder: true,
items: [
{
xtype: 'pveStorageSelector',
reference: 'storage',
isFormField: false,
fieldLabel: gettext('Storage'),
labelAlign: 'right',
storageContent: 'iso',
allowBlank: false,
cbind: {
nodename: '{nodename}',
autoSelect: '{insideWizard}',
insideWizard: '{insideWizard}',
disabled: '{disabled}',
},
listeners: {
change: function(f, value) {
let me = this;
let selector = me.up('pveIsoSelector');
selector.lookup('file').setStorage(value);
selector.checkChange();
},
},
},
{
xtype: 'pveFileSelector',
reference: 'file',
isFormField: false,
storageContent: 'iso',
fieldLabel: gettext('ISO image'),
labelAlign: 'right',
cbind: {
nodename: '{nodename}',
disabled: '{disabled}',
},
allowBlank: false,
listeners: {
change: function() {
this.up('pveIsoSelector').checkChange();
},
},
},
],
});
Ext.define('PVE.grid.BackupView', {
extend: 'Ext.grid.GridPanel',
alias: ['widget.pveBackupView'],
onlineHelp: 'chapter_vzdump',
stateful: true,
stateId: 'grid-guest-backup',
initComponent: function() {
var me = this;
var nodename = me.pveSelNode.data.node;
if (!nodename) {
throw "no node name specified";
}
var vmid = me.pveSelNode.data.vmid;
if (!vmid) {
throw "no VM ID specified";
}
var vmtype = me.pveSelNode.data.type;
if (!vmtype) {
throw "no VM type specified";
}
var vmtypeFilter;
if (vmtype === 'lxc' || vmtype === 'openvz') {
vmtypeFilter = function(item) {
return PVE.Utils.volume_is_lxc_backup(item.data.volid, item.data.format);
};
} else if (vmtype === 'qemu') {
vmtypeFilter = function(item) {
return PVE.Utils.volume_is_qemu_backup(item.data.volid, item.data.format);
};
} else {
throw "unsupported VM type '" + vmtype + "'";
}
var searchFilter = {
property: 'volid',
value: '',
anyMatch: true,
caseSensitive: false,
};
var vmidFilter = {
property: 'vmid',
value: vmid,
exactMatch: true,
};
me.store = Ext.create('Ext.data.Store', {
model: 'pve-storage-content',
sorters: [
{
property: 'vmid',
direction: 'ASC',
},
{
property: 'vdate',
direction: 'DESC',
},
],
filters: [
vmtypeFilter,
searchFilter,
vmidFilter,
],
});
let updateFilter = function() {
me.store.filter([
vmtypeFilter,
searchFilter,
vmidFilter,
]);
};
const reload = Ext.Function.createBuffered((options) => {
if (me.store) {
me.store.load(options);
}
}, 100);
let isPBS = false;
var setStorage = function(storage) {
var url = '/api2/json/nodes/' + nodename + '/storage/' + storage + '/content';
url += '?content=backup';
me.store.setProxy({
type: 'proxmox',
url: url,
});
Proxmox.Utils.monStoreErrors(me.view, me.store, true);
reload();
};
let file_restore_btn;
var storagesel = Ext.create('PVE.form.StorageSelector', {
nodename: nodename,
fieldLabel: gettext('Storage'),
labelAlign: 'right',
storageContent: 'backup',
allowBlank: false,
listeners: {
change: function(f, value) {
let storage = f.getStore().findRecord('storage', value, 0, false, true, true);
if (storage) {
isPBS = storage.data.type === 'pbs';
me.getColumns().forEach((column) => {
let id = column.dataIndex;
if (id === 'verification' || id === 'encrypted') {
column.setHidden(!isPBS);
}
});
} else {
isPBS = false;
}
setStorage(value);
if (file_restore_btn) {
file_restore_btn.setHidden(!isPBS);
}
},
},
});
var storagefilter = Ext.create('Ext.form.field.Text', {
fieldLabel: gettext('Search'),
labelWidth: 50,
labelAlign: 'right',
enableKeyEvents: true,
value: searchFilter.value,
listeners: {
buffer: 500,
keyup: function(field) {
me.store.clearFilter(true);
searchFilter.value = field.getValue();
updateFilter();
},
},
});
var vmidfilterCB = Ext.create('Ext.form.field.Checkbox', {
boxLabel: gettext('Filter VMID'),
value: '1',
listeners: {
change: function(cb, value) {
vmidFilter.value = value ? vmid : '';
vmidFilter.exactMatch = !!value;
updateFilter();
},
},
});
var sm = Ext.create('Ext.selection.RowModel', {});
var backup_btn = Ext.create('Ext.button.Button', {
text: gettext('Backup now'),
handler: function() {
var win = Ext.create('PVE.window.Backup', {
nodename: nodename,
vmid: vmid,
vmtype: vmtype,
storage: storagesel.getValue(),
listeners: {
close: function() {
reload();
},
},
});
win.show();
},
});
var restore_btn = Ext.create('Proxmox.button.Button', {
text: gettext('Restore'),
disabled: true,
selModel: sm,
enableFn: function(rec) {
return !!rec;
},
handler: function(b, e, rec) {
let win = Ext.create('PVE.window.Restore', {
nodename: nodename,
vmid: vmid,
volid: rec.data.volid,
volidText: PVE.Utils.render_storage_content(rec.data.volid, {}, rec),
vmtype: vmtype,
isPBS: isPBS,
});
win.show();
win.on('destroy', reload);
},
});
let delete_btn = Ext.create('Proxmox.button.StdRemoveButton', {
selModel: sm,
dangerous: true,
delay: 5,
enableFn: rec => !rec?.data?.protected,
confirmMsg: ({ data }) => {
let msg = Ext.String.format(
gettext('Are you sure you want to remove entry {0}'), `'${data.volid}'`);
return msg + " " + gettext('This will permanently erase all data.');
},
getUrl: ({ data }) => `/nodes/${nodename}/storage/${storagesel.getValue()}/content/${data.volid}`,
callback: () => reload(),
});
let config_btn = Ext.create('Proxmox.button.Button', {
text: gettext('Show Configuration'),
disabled: true,
selModel: sm,
enableFn: rec => !!rec,
handler: function(b, e, rec) {
let storage = storagesel.getValue();
if (!storage) {
return;
}
Ext.create('PVE.window.BackupConfig', {
volume: rec.data.volid,
pveSelNode: me.pveSelNode,
autoShow: true,
});
},
});
// declared above so that the storage selector can change this buttons hidden state
file_restore_btn = Ext.create('Proxmox.button.Button', {
text: gettext('File Restore'),
disabled: true,
selModel: sm,
enableFn: rec => !!rec && isPBS,
hidden: !isPBS,
handler: function(b, e, rec) {
let storage = storagesel.getValue();
let isVMArchive = PVE.Utils.volume_is_qemu_backup(rec.data.volid, rec.data.format);
Ext.create('Proxmox.window.FileBrowser', {
title: gettext('File Restore') + " - " + rec.data.text,
listURL: `/api2/json/nodes/localhost/storage/${storage}/file-restore/list`,
downloadURL: `/api2/json/nodes/localhost/storage/${storage}/file-restore/download`,
extraParams: {
volume: rec.data.volid,
},
archive: isVMArchive ? 'all' : undefined,
autoShow: true,
});
},
});
Ext.apply(me, {
selModel: sm,
tbar: {
overflowHandler: 'scroller',
items: [
backup_btn,
'-',
restore_btn,
file_restore_btn,
config_btn,
{
xtype: 'proxmoxButton',
text: gettext('Edit Notes'),
disabled: true,
handler: function() {
let volid = sm.getSelection()[0].data.volid;
var storage = storagesel.getValue();
Ext.create('Proxmox.window.Edit', {
autoLoad: true,
width: 600,
height: 400,
resizable: true,
title: gettext('Notes'),
url: `/api2/extjs/nodes/${nodename}/storage/${storage}/content/${volid}`,
layout: 'fit',
items: [
{
xtype: 'textarea',
layout: 'fit',
name: 'notes',
height: '100%',
},
],
listeners: {
destroy: () => reload(),
},
}).show();
},
},
{
xtype: 'proxmoxButton',
text: gettext('Change Protection'),
disabled: true,
handler: function(button, event, record) {
let volid = record.data.volid, storage = storagesel.getValue();
let url = `/api2/extjs/nodes/${nodename}/storage/${storage}/content/${volid}`;
Proxmox.Utils.API2Request({
url: url,
method: 'PUT',
waitMsgTarget: me,
params: {
'protected': record.data.protected ? 0 : 1,
},
failure: (response) => Ext.Msg.alert('Error', response.htmlStatus),
success: () => {
reload({
callback: () => sm.fireEvent('selectionchange', sm, [record]),
});
},
});
},
},
'-',
delete_btn,
'->',
storagesel,
'-',
vmidfilterCB,
storagefilter,
],
},
columns: [
{
header: gettext('Name'),
flex: 2,
sortable: true,
renderer: PVE.Utils.render_storage_content,
dataIndex: 'volid',
},
{
header: gettext('Notes'),
dataIndex: 'notes',
flex: 1,
renderer: Ext.htmlEncode,
},
{
header: `' + Ext.htmlEncode(errors[name]) + '
';
metaData.tdAttr = 'data-qwidth=600 data-qtitle="ERROR" data-qtip="' + html + '"';
}
return value;
};
let columns = [
{
// similar to xtype: 'rownumberer',
dataIndex: 'pos',
resizable: false,
minWidth: 65,
maxWidth: 83,
flex: 1,
sortable: false,
hideable: false,
menuDisabled: true,
renderer: function(value, metaData, record, rowIdx, colIdx) {
metaData.tdCls = Ext.baseCSSPrefix + 'grid-cell-special';
let dragHandle = "${comment} `;
}
return comment;
},
},
);
Ext.apply(me, {
store: store,
selModel: sm,
tbar: tbar,
viewConfig: {
plugins: [
{
ptype: 'gridviewdragdrop',
dragGroup: 'FWRuleDDGroup',
dropGroup: 'FWRuleDDGroup',
},
],
listeners: {
beforedrop: function(node, data, dropRec, dropPosition) {
if (!dropRec) {
return false; // empty view
}
let moveto = dropRec.get('pos');
if (dropPosition === 'after') {
moveto++;
}
let pos = data.records[0].get('pos');
me.moveRule(pos, moveto);
return 0;
},
itemdblclick: run_editor,
},
},
sortableColumns: false,
columns: columns,
});
me.callParent();
if (me.base_url) {
me.setBaseUrl(me.base_url); // load
}
},
}, function() {
Ext.define('pve-fw-rule', {
extend: 'Ext.data.Model',
fields: [
{ name: 'enable', type: 'boolean' },
'type',
'action',
'macro',
'source',
'dest',
'proto',
'iface',
'dport',
'sport',
'comment',
'pos',
'digest',
'errors',
],
idProperty: 'pos',
});
});
Ext.define('PVE.pool.AddVM', {
extend: 'Proxmox.window.Edit',
width: 640,
height: 480,
isAdd: true,
isCreate: true,
extraRequestParams: {
'allow-move': 1,
},
initComponent: function() {
var me = this;
if (!me.pool) {
throw "no pool specified";
}
me.url = '/pools/';
me.method = 'PUT';
me.extraRequestParams.poolid = me.pool;
var vmsField = Ext.create('Ext.form.field.Text', {
name: 'vms',
hidden: true,
allowBlank: false,
});
var vmStore = Ext.create('Ext.data.Store', {
model: 'PVEResources',
sorters: [
{
property: 'vmid',
direction: 'ASC',
},
],
filters: [
function(item) {
return (item.data.type === 'lxc' || item.data.type === 'qemu') &&item.data.pool !== me.pool;
},
],
});
var vmGrid = Ext.create('widget.grid', {
store: vmStore,
border: true,
height: 360,
scrollable: true,
selModel: {
selType: 'checkboxmodel',
mode: 'SIMPLE',
listeners: {
selectionchange: function(model, selected, opts) {
var selectedVms = [];
selected.forEach(function(vm) {
selectedVms.push(vm.data.vmid);
});
vmsField.setValue(selectedVms);
},
},
},
columns: [
{
header: 'ID',
dataIndex: 'vmid',
width: 60,
},
{
header: gettext('Node'),
dataIndex: 'node',
},
{
header: gettext('Current Pool'),
dataIndex: 'pool',
},
{
header: gettext('Status'),
dataIndex: 'uptime',
renderer: v => v ? Proxmox.Utils.runningText : Proxmox.Utils.stoppedText,
},
{
header: gettext('Name'),
dataIndex: 'name',
flex: 1,
},
{
header: gettext('Type'),
dataIndex: 'type',
},
],
});
Ext.apply(me, {
subject: gettext('Virtual Machine'),
items: [
vmsField,
vmGrid,
{
xtype: 'displayfield',
userCls: 'pmx-hint',
value: gettext('Selected guests who are already part of a pool will be removed from it first.'),
},
],
});
me.callParent();
vmStore.load();
},
});
Ext.define('PVE.pool.AddStorage', {
extend: 'Proxmox.window.Edit',
initComponent: function() {
var me = this;
if (!me.pool) {
throw "no pool specified";
}
me.isCreate = true;
me.isAdd = true;
me.url = "/pools/";
me.method = 'PUT';
me.extraRequestParams.poolid = me.pool;
Ext.apply(me, {
subject: gettext('Storage'),
width: 350,
items: [
{
xtype: 'pveStorageSelector',
name: 'storage',
nodename: 'localhost',
autoSelect: false,
value: '',
fieldLabel: gettext("Storage"),
},
],
});
me.callParent();
},
});
Ext.define('PVE.grid.PoolMembers', {
extend: 'Ext.grid.GridPanel',
alias: ['widget.pvePoolMembers'],
// fixme: dynamic status update ?
stateful: true,
stateId: 'grid-pool-members',
initComponent: function() {
var me = this;
if (!me.pool) {
throw "no pool specified";
}
var store = Ext.create('Ext.data.Store', {
model: 'PVEResources',
sorters: [
{
property: 'type',
direction: 'ASC',
},
],
proxy: {
type: 'proxmox',
root: 'data[0].members',
url: "/api2/json/pools/?poolid=" + me.pool,
},
});
var coldef = PVE.data.ResourceStore.defaultColumns().filter((c) =>
c.dataIndex !== 'tags' && c.dataIndex !== 'lock',
);
var reload = function() {
store.load();
};
var sm = Ext.create('Ext.selection.RowModel', {});
var remove_btn = new Proxmox.button.Button({
text: gettext('Remove'),
disabled: true,
selModel: sm,
confirmMsg: function(rec) {
return Ext.String.format(gettext('Are you sure you want to remove entry {0}'),
"'" + rec.data.id + "'");
},
handler: function(btn, event, rec) {
var params = { 'delete': 1, poolid: me.pool };
if (rec.data.type === 'storage') {
params.storage = rec.data.storage;
} else if (rec.data.type === 'qemu' || rec.data.type === 'lxc' || rec.data.type === 'openvz') {
params.vms = rec.data.vmid;
} else {
throw "unknown resource type";
}
Proxmox.Utils.API2Request({
url: '/pools/',
method: 'PUT',
params: params,
waitMsgTarget: me,
callback: function() {
reload();
},
failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
},
});
},
});
Ext.apply(me, {
store: store,
selModel: sm,
tbar: [
{
text: gettext('Add'),
menu: new Ext.menu.Menu({
items: [
{
text: gettext('Virtual Machine'),
iconCls: 'pve-itype-icon-qemu',
handler: function() {
var win = Ext.create('PVE.pool.AddVM', { pool: me.pool });
win.on('destroy', reload);
win.show();
},
},
{
text: gettext('Storage'),
iconCls: 'pve-itype-icon-storage',
handler: function() {
var win = Ext.create('PVE.pool.AddStorage', { pool: me.pool });
win.on('destroy', reload);
win.show();
},
},
],
}),
},
remove_btn,
],
viewConfig: {
stripeRows: true,
},
columns: coldef,
listeners: {
itemcontextmenu: PVE.Utils.createCmdMenu,
itemdblclick: function(v, record) {
var ws = me.up('pveStdWorkspace');
ws.selectById(record.data.id);
},
activate: reload,
},
});
me.callParent();
},
});
Ext.define('PVE.window.ReplicaEdit', {
extend: 'Proxmox.window.Edit',
xtype: 'pveReplicaEdit',
subject: gettext('Replication Job'),
url: '/cluster/replication',
method: 'POST',
initComponent: function() {
var me = this;
var vmid = me.pveSelNode.data.vmid;
var nodename = me.pveSelNode.data.node;
var items = [];
items.push({
xtype: me.isCreate && !vmid?'pveGuestIDSelector':'displayfield',
name: 'guest',
fieldLabel: 'CT/VM ID',
value: vmid || '',
});
items.push(
{
xtype: me.isCreate ? 'pveNodeSelector':'displayfield',
name: 'target',
disallowedNodes: [nodename],
allowBlank: false,
onlineValidator: true,
fieldLabel: gettext("Target"),
},
{
xtype: 'pveCalendarEvent',
fieldLabel: gettext('Schedule'),
emptyText: '*/15 - ' + Ext.String.format(gettext('Every {0} minutes'), 15),
name: 'schedule',
},
{
xtype: 'numberfield',
fieldLabel: gettext('Rate limit') + ' (MB/s)',
step: 1,
minValue: 1,
emptyText: gettext('unlimited'),
name: 'rate',
},
{
xtype: 'textfield',
fieldLabel: gettext('Comment'),
name: 'comment',
},
{
xtype: 'proxmoxcheckbox',
name: 'enabled',
defaultValue: 'on',
checked: true,
fieldLabel: gettext('Enabled'),
},
);
me.items = [
{
xtype: 'inputpanel',
itemId: 'ipanel',
onlineHelp: 'pvesr_schedule_time_format',
onGetValues: function(values) {
let win = this.up('window');
values.disable = values.enabled ? 0 : 1;
delete values.enabled;
PVE.Utils.delete_if_default(values, 'rate', '', win.isCreate);
PVE.Utils.delete_if_default(values, 'disable', 0, win.isCreate);
PVE.Utils.delete_if_default(values, 'schedule', '*/15', win.isCreate);
PVE.Utils.delete_if_default(values, 'comment', '', win.isCreate);
if (win.isCreate) {
values.type = 'local';
let vm = vmid || values.guest;
let id = -1;
if (win.highestids[vm] !== undefined) {
id = win.highestids[vm];
}
id++;
values.id = vm + '-' + id.toString();
delete values.guest;
}
return values;
},
items: items,
},
];
me.callParent();
if (me.isCreate) {
me.load({
success: function(response) {
var jobs = response.result.data;
var highestids = {};
Ext.Array.forEach(jobs, function(job) {
var match = /^([0-9]+)-([0-9]+)$/.exec(job.id);
if (match) {
let jobVMID = parseInt(match[1], 10);
let id = parseInt(match[2], 10);
if (highestids[jobVMID] === undefined || highestids[jobVMID] < id) {
highestids[jobVMID] = id;
}
}
});
me.highestids = highestids;
},
});
} else {
me.load({
success: function(response, options) {
response.result.data.enabled = !response.result.data.disable;
me.setValues(response.result.data);
me.digest = response.result.data.digest;
},
});
}
},
});
/* callback is a function and string */
Ext.define('PVE.grid.ReplicaView', {
extend: 'Ext.grid.Panel',
xtype: 'pveReplicaView',
onlineHelp: 'chapter_pvesr',
stateful: true,
stateId: 'grid-pve-replication-status',
controller: {
xclass: 'Ext.app.ViewController',
addJob: function(button, event, rec) {
let me = this;
let view = me.getView();
Ext.create('PVE.window.ReplicaEdit', {
isCreate: true,
method: 'POST',
pveSelNode: view.pveSelNode,
listeners: {
destroy: () => me.reload(),
},
autoShow: true,
});
},
editJob: function(button, event, { data }) {
let me = this;
let view = me.getView();
Ext.create('PVE.window.ReplicaEdit', {
url: `/cluster/replication/${data.id}`,
method: 'PUT',
pveSelNode: view.pveSelNode,
listeners: {
destroy: () => me.reload(),
},
autoShow: true,
});
},
scheduleJobNow: function(button, event, rec) {
let me = this;
let view = me.getView();
Proxmox.Utils.API2Request({
url: `/api2/extjs/nodes/${view.nodename}/replication/${rec.data.id}/schedule_now`,
method: 'POST',
waitMsgTarget: view,
callback: () => me.reload(),
failure: (response, opts) => Ext.Msg.alert(gettext('Error'), response.htmlStatus),
});
},
showLog: function(button, event, rec) {
let me = this;
let view = this.getView();
let logView = Ext.create('Proxmox.panel.LogView', {
border: false,
url: `/api2/extjs/nodes/${view.nodename}/replication/${rec.data.id}/log`,
});
let task = Ext.TaskManager.newTask({
run: () => logView.requestUpdate(),
interval: 1000,
});
let win = Ext.create('Ext.window.Window', {
items: [logView],
layout: 'fit',
width: 800,
height: 400,
modal: true,
title: gettext("Replication Log"),
listeners: {
destroy: function() {
task.stop();
me.reload();
},
},
});
task.start();
win.show();
},
reload: function() {
this.getView().rstore.load();
},
dblClick: function(grid, record, item) {
this.editJob(undefined, undefined, record);
},
// currently replication is for cluster only, so disable the whole component for non-cluster
checkPrerequisites: function() {
let view = this.getView();
if (PVE.Utils.isStandaloneNode()) {
view.mask(gettext("Replication needs at least two nodes"), ['pve-static-mask']);
}
},
control: {
'#': {
itemdblclick: 'dblClick',
afterlayout: 'checkPrerequisites',
},
},
},
tbar: [
{
text: gettext('Add'),
itemId: 'addButton',
handler: 'addJob',
},
{
xtype: 'proxmoxButton',
text: gettext('Edit'),
itemId: 'editButton',
handler: 'editJob',
disabled: true,
},
{
xtype: 'proxmoxStdRemoveButton',
itemId: 'removeButton',
baseurl: '/api2/extjs/cluster/replication/',
dangerous: true,
callback: 'reload',
},
{
xtype: 'proxmoxButton',
text: gettext('Log'),
itemId: 'logButton',
handler: 'showLog',
disabled: true,
},
{
xtype: 'proxmoxButton',
text: gettext('Schedule now'),
itemId: 'scheduleNowButton',
handler: 'scheduleJobNow',
disabled: true,
},
],
initComponent: function() {
var me = this;
var mode = '';
var url = '/cluster/replication';
me.nodename = me.pveSelNode.data.node;
me.vmid = me.pveSelNode.data.vmid;
me.columns = [
{
header: gettext('Enabled'),
width: 80,
dataIndex: 'enabled',
align: 'center',
renderer: Proxmox.Utils.renderEnabledIcon,
sortable: true,
},
{
text: 'ID',
dataIndex: 'id',
width: 60,
hidden: true,
},
{
text: gettext('Guest'),
dataIndex: 'guest',
width: 75,
},
{
text: gettext('Job'),
dataIndex: 'jobnum',
width: 60,
},
{
text: gettext('Target'),
dataIndex: 'target',
},
];
if (!me.nodename) {
mode = 'dc';
me.stateId = 'grid-pve-replication-dc';
} else if (!me.vmid) {
mode = 'node';
url = `/nodes/${me.nodename}/replication`;
} else {
mode = 'vm';
url = `/nodes/${me.nodename}/replication?guest=${me.vmid}`;
}
if (mode !== 'dc') {
me.columns.push(
{
text: gettext('Status'),
dataIndex: 'state',
minWidth: 160,
flex: 1,
renderer: function(value, metadata, record) {
if (record.data.pid) {
metadata.tdCls = 'x-grid-row-loading';
return '';
}
let icons = [], states = [];
if (record.data.remove_job) {
icons.push('{title} ',
'IPSet: ', me.addBtn, me.removeBtn, me.editBtn],
selModel: sm,
columns: [
{ header: 'IPSet', dataIndex: 'name', width: '100' },
{ header: gettext('Comment'), dataIndex: 'comment', renderer: Ext.String.htmlEncode, flex: 1 },
],
listeners: {
itemdblclick: run_editor,
select: function(_, rec) {
var url = me.base_url + '/' + rec.data.name;
me.ipset_panel.setBaseUrl(url);
},
deselect: function() {
me.ipset_panel.setBaseUrl(undefined);
},
show: reload,
},
});
if (!canEdit) {
me.addBtn.setDisabled(true);
}
me.callParent();
store.load();
},
});
Ext.define('PVE.IPSetCidrEdit', {
extend: 'Proxmox.window.Edit',
cidr: undefined,
initComponent: function() {
var me = this;
me.isCreate = me.cidr === undefined;
if (me.isCreate) {
me.url = '/api2/extjs' + me.base_url;
me.method = 'POST';
} else {
me.url = '/api2/extjs' + me.base_url + '/' + me.cidr;
me.method = 'PUT';
}
var column1 = [];
if (me.isCreate) {
if (!me.list_refs_url) {
throw "no alias_base_url specified";
}
column1.push({
xtype: 'pveIPRefSelector',
name: 'cidr',
ref_type: 'alias',
autoSelect: false,
editable: true,
base_url: me.list_refs_url,
allowBlank: false,
fieldLabel: gettext('IP/CIDR'),
});
} else {
column1.push({
xtype: 'displayfield',
name: 'cidr',
value: '',
fieldLabel: gettext('IP/CIDR'),
});
}
var ipanel = Ext.create('Proxmox.panel.InputPanel', {
isCreate: me.isCreate,
column1: column1,
column2: [
{
xtype: 'proxmoxcheckbox',
name: 'nomatch',
checked: false,
uncheckedValue: 0,
fieldLabel: 'nomatch',
},
],
columnB: [
{
xtype: 'textfield',
name: 'comment',
value: '',
fieldLabel: gettext('Comment'),
},
],
});
Ext.apply(me, {
subject: gettext('IP/CIDR'),
items: [ipanel],
});
me.callParent();
if (!me.isCreate) {
me.load({
success: function(response, options) {
var values = response.result.data;
ipanel.setValues(values);
},
});
}
},
});
Ext.define('PVE.IPSetGrid', {
extend: 'Ext.grid.Panel',
alias: 'widget.pveIPSetGrid',
stateful: true,
stateId: 'grid-firewall-ipsets',
base_url: undefined,
list_refs_url: undefined,
addBtn: undefined,
removeBtn: undefined,
editBtn: undefined,
setBaseUrl: function(url) {
var me = this;
me.base_url = url;
if (url === undefined) {
me.addBtn.setDisabled(true);
me.store.removeAll();
} else {
if (me.canEdit) {
me.addBtn.setDisabled(false);
}
me.removeBtn.baseurl = url + '/';
me.store.setProxy({
type: 'proxmox',
url: '/api2/json' + url,
});
me.store.load();
}
},
initComponent: function() {
var me = this;
if (!me.list_refs_url) {
throw "no1 list_refs_url specified";
}
var store = new Ext.data.Store({
model: 'pve-ipset',
});
var reload = function() {
store.load();
};
var sm = Ext.create('Ext.selection.RowModel', {});
me.caps = Ext.state.Manager.get('GuiCap');
me.canEdit = !!me.caps.vms['VM.Config.Network'] || !!me.caps.dc['Sys.Modify'] || !!me.caps.nodes['Sys.Modify'];
var run_editor = function() {
var rec = sm.getSelection()[0];
if (!rec || !me.canEdit) {
return;
}
var win = Ext.create('PVE.IPSetCidrEdit', {
base_url: me.base_url,
cidr: rec.data.cidr,
});
win.show();
win.on('destroy', reload);
};
me.editBtn = new Proxmox.button.Button({
text: gettext('Edit'),
disabled: true,
enableFn: rec => me.canEdit,
selModel: sm,
handler: run_editor,
});
me.addBtn = new Proxmox.button.Button({
text: gettext('Add'),
disabled: true,
enableFn: rec => me.canEdit,
handler: function() {
if (!me.base_url) {
return;
}
var win = Ext.create('PVE.IPSetCidrEdit', {
base_url: me.base_url,
list_refs_url: me.list_refs_url,
});
win.show();
win.on('destroy', reload);
},
});
me.removeBtn = Ext.create('Proxmox.button.StdRemoveButton', {
disabled: true,
enableFn: rec => me.canEdit,
selModel: sm,
baseurl: me.base_url + '/',
callback: reload,
});
var render_errors = function(value, metaData, record) {
var errors = record.data.errors;
if (errors) {
var msg = errors.cidr || errors.nomatch;
if (msg) {
metaData.tdCls = 'proxmox-invalid-row';
var html = '' + Ext.htmlEncode(msg) + '
';
metaData.tdAttr = 'data-qwidth=600 data-qtitle="ERROR" data-qtip="' +
html.replace(/"/g, '"') + '"';
}
}
return value;
};
Ext.apply(me, {
tbar: ['IP/CIDR: ', me.addBtn, me.removeBtn, me.editBtn],
store: store,
selModel: sm,
listeners: {
itemdblclick: run_editor,
},
columns: [
{
xtype: 'rownumberer',
},
{
header: gettext('IP/CIDR'),
dataIndex: 'cidr',
width: 150,
renderer: function(value, metaData, record) {
value = render_errors(value, metaData, record);
if (record.data.nomatch) {
return '! ' + value;
}
return value;
},
},
{
header: gettext('Comment'),
dataIndex: 'comment',
flex: 1,
renderer: function(value) {
return Ext.util.Format.htmlEncode(value);
},
},
],
});
me.callParent();
if (me.base_url) {
me.setBaseUrl(me.base_url); // load
}
},
}, function() {
Ext.define('pve-ipset', {
extend: 'Ext.data.Model',
fields: [{ name: 'nomatch', type: 'boolean' },
'cidr', 'comment', 'errors'],
idProperty: 'cidr',
});
});
Ext.define('PVE.IPSet', {
extend: 'Ext.panel.Panel',
alias: 'widget.pveIPSet',
title: 'IPSet',
onlineHelp: 'pve_firewall_ip_sets',
list_refs_url: undefined,
initComponent: function() {
var me = this;
if (!me.list_refs_url) {
throw "no list_refs_url specified";
}
var ipset_panel = Ext.createWidget('pveIPSetGrid', {
region: 'center',
list_refs_url: me.list_refs_url,
border: false,
});
var ipset_list = Ext.createWidget('pveIPSetList', {
region: 'west',
ipset_panel: ipset_panel,
base_url: me.base_url,
width: '50%',
border: false,
split: true,
});
Ext.apply(me, {
layout: 'border',
items: [ipset_list, ipset_panel],
listeners: {
show: function() {
ipset_list.fireEvent('show', ipset_list);
},
},
});
me.callParent();
},
});
/*
* This is a running chart widget you add time datapoints to it, and we only
* show the last x of it used for ceph performance charts
*/
Ext.define('PVE.widget.RunningChart', {
extend: 'Ext.container.Container',
alias: 'widget.pveRunningChart',
layout: {
type: 'hbox',
align: 'center',
},
items: [
{
width: 80,
xtype: 'box',
itemId: 'title',
data: {
title: '',
},
tpl: '{title}: ',
},
{
flex: 1,
xtype: 'cartesian',
height: '100%',
itemId: 'chart',
border: false,
axes: [
{
type: 'numeric',
position: 'left',
hidden: true,
minimum: 0,
},
{
type: 'numeric',
position: 'bottom',
hidden: true,
},
],
store: {
trackRemoved: false,
data: {},
},
sprites: [{
id: 'valueSprite',
type: 'text',
text: '0 B/s',
textAlign: 'end',
textBaseline: 'middle',
fontSize: 14,
}],
series: [{
type: 'line',
xField: 'time',
yField: 'val',
fill: 'true',
colors: ['#cfcfcf'],
tooltip: {
trackMouse: true,
renderer: function(tooltip, record, ctx) {
if (!record || !record.data) return;
const view = this.getChart();
const date = new Date(record.data.time);
const value = view.up().renderer(record.data.val);
const line1 = `${view.up().title}: ${value}`;
const line2 = Ext.Date.format(date, 'H:i:s');
tooltip.setHtml(`${line1}${me.getRecordValue('name') + text}
`;
if (me.pveSelNode.data.type === 'lxc' && me.ostype && me.ostype !== 'unmanaged') {
// Manual mappings for distros with special casing
const namemap = {
'archlinux': 'Arch Linux',
'nixos': 'NixOS',
'opensuse': 'openSUSE',
'centos': 'CentOS',
};
const distro = namemap[me.ostype] ?? Ext.String.capitalize(me.ostype);
title += `
`;
}
me.setTitle(title);
},
});
Ext.define('PVE.guest.Summary', {
extend: 'Ext.panel.Panel',
xtype: 'pveGuestSummary',
scrollable: true,
bodyPadding: 5,
initComponent: function() {
var me = this;
var nodename = me.pveSelNode.data.node;
if (!nodename) {
throw "no node name specified";
}
var vmid = me.pveSelNode.data.vmid;
if (!vmid) {
throw "no VM ID specified";
}
if (!me.workspace) {
throw "no workspace specified";
}
if (!me.statusStore) {
throw "no status storage specified";
}
var type = me.pveSelNode.data.type;
var template = !!me.pveSelNode.data.template;
var rstore = me.statusStore;
var items = [
{
xtype: template ? 'pveTemplateStatusView' : 'pveGuestStatusView',
flex: 1,
padding: template ? '5' : '0 5 0 0',
itemId: 'gueststatus',
pveSelNode: me.pveSelNode,
rstore: rstore,
},
{
xtype: 'pmxNotesView',
flex: 1,
padding: template ? '5' : '0 0 0 5',
itemId: 'notesview',
pveSelNode: me.pveSelNode,
},
];
var rrdstore;
if (!template) {
// in non-template mode put the two panels always together
items = [
{
xtype: 'container',
height: 300,
layout: {
type: 'hbox',
align: 'stretch',
},
items: items,
},
];
rrdstore = Ext.create('Proxmox.data.RRDStore', {
rrdurl: `/api2/json/nodes/${nodename}/${type}/${vmid}/rrddata`,
model: 'pve-rrd-guest',
});
items.push(
{
xtype: 'proxmoxRRDChart',
title: gettext('CPU usage'),
pveSelNode: me.pveSelNode,
fields: ['cpu'],
fieldTitles: [gettext('CPU usage')],
unit: 'percent',
store: rrdstore,
},
{
xtype: 'proxmoxRRDChart',
title: gettext('Memory usage'),
pveSelNode: me.pveSelNode,
fields: ['maxmem', 'mem'],
fieldTitles: [gettext('Total'), gettext('RAM usage')],
unit: 'bytes',
powerOfTwo: true,
store: rrdstore,
},
{
xtype: 'proxmoxRRDChart',
title: gettext('Network traffic'),
pveSelNode: me.pveSelNode,
fields: ['netin', 'netout'],
store: rrdstore,
},
{
xtype: 'proxmoxRRDChart',
title: gettext('Disk IO'),
pveSelNode: me.pveSelNode,
fields: ['diskread', 'diskwrite'],
store: rrdstore,
},
);
}
Ext.apply(me, {
tbar: ['->', { xtype: 'proxmoxRRDTypeSelector' }],
items: [
{
xtype: 'container',
itemId: 'itemcontainer',
layout: {
type: 'column',
},
minWidth: 700,
defaults: {
minHeight: 330,
padding: 5,
},
items: items,
listeners: {
resize: function(container) {
Proxmox.Utils.updateColumns(container);
},
},
},
],
});
me.callParent();
if (!template) {
rrdstore.startUpdate();
me.on('destroy', rrdstore.stopUpdate);
}
let sp = Ext.state.Manager.getProvider();
me.mon(sp, 'statechange', function(provider, key, value) {
if (key !== 'summarycolumns') {
return;
}
Proxmox.Utils.updateColumns(me.getComponent('itemcontainer'));
});
},
});
Ext.define('PVE.panel.TemplateStatusView', {
extend: 'Proxmox.panel.StatusView',
alias: 'widget.pveTemplateStatusView',
layout: {
type: 'vbox',
align: 'stretch',
},
defaults: {
xtype: 'pmxInfoWidget',
printBar: false,
padding: '2 25',
},
items: [
{
xtype: 'box',
height: 20,
},
{
itemId: 'hamanaged',
iconCls: 'fa fa-heartbeat fa-fw',
title: gettext('HA State'),
printBar: false,
textField: 'ha',
renderer: PVE.Utils.format_ha,
},
{
itemId: 'node',
iconCls: 'fa fa-fw fa-building',
title: gettext('Node'),
},
{
xtype: 'box',
height: 20,
},
{
itemId: 'cpus',
iconCls: 'fa fa-fw pmx-itype-icon-processor pmx-icon',
title: gettext('Processors'),
textField: 'cpus',
},
{
itemId: 'memory',
iconCls: 'fa fa-fw pmx-itype-icon-memory pmx-icon',
title: gettext('Memory'),
textField: 'maxmem',
renderer: Proxmox.Utils.render_size,
},
{
itemId: 'swap',
iconCls: 'fa fa-refresh fa-fw',
title: gettext('Swap'),
textField: 'maxswap',
renderer: Proxmox.Utils.render_size,
},
{
itemId: 'disk',
iconCls: 'fa fa-hdd-o fa-fw',
title: gettext('Bootdisk size'),
textField: 'maxdisk',
renderer: Proxmox.Utils.render_size,
},
{
xtype: 'box',
height: 20,
},
],
initComponent: function() {
var me = this;
var name = me.pveSelNode.data.name;
if (!name) {
throw "no name specified";
}
me.title = name;
me.callParent();
if (me.pveSelNode.data.type !== 'lxc') {
me.remove(me.getComponent('swap'));
}
me.getComponent('node').updateValue(me.pveSelNode.data.node);
},
});
Ext.define('PVE.panel.MultiDiskPanel', {
extend: 'Ext.panel.Panel',
setNodename: function(nodename) {
this.items.each((panel) => panel.setNodename(nodename));
},
border: false,
bodyBorder: false,
layout: 'card',
controller: {
xclass: 'Ext.app.ViewController',
vmconfig: {},
onAdd: function() {
let me = this;
me.lookup('addButton').setDisabled(true);
me.addDisk();
let count = me.lookup('grid').getStore().getCount() + 1; // +1 is from ide2
me.lookup('addButton').setDisabled(count >= me.maxCount);
},
getNextFreeDisk: function(vmconfig) {
throw "implement in subclass";
},
addPanel: function(itemId, vmconfig, nextFreeDisk) {
throw "implement in subclass";
},
// define in subclass
diskSorter: undefined,
addDisk: function() {
let me = this;
let grid = me.lookup('grid');
let store = grid.getStore();
// get free disk id
let vmconfig = me.getVMConfig(true);
let nextFreeDisk = me.getNextFreeDisk(vmconfig);
if (!nextFreeDisk) {
return;
}
// add store entry + panel
let itemId = 'disk-card-' + ++Ext.idSeed;
let rec = store.add({
name: nextFreeDisk.confid,
itemId,
})[0];
let panel = me.addPanel(itemId, vmconfig, nextFreeDisk);
panel.updateVMConfig(vmconfig);
// we need to setup a validitychange handler, so that we can show
// that a disk has invalid fields
let fields = panel.query('field');
fields.forEach((el) => el.on('validitychange', () => {
let valid = fields.every((field) => field.isValid());
rec.set('valid', valid);
me.checkValidity();
}));
store.sort(me.diskSorter);
// select if the panel added is the only one
if (store.getCount() === 1) {
grid.getSelectionModel().select(0, false);
}
},
getBaseVMConfig: function() {
throw "implement in subclass";
},
getVMConfig: function(all) {
let me = this;
let vmconfig = me.getBaseVMConfig();
me.lookup('grid').getStore().each((rec) => {
if (all || rec.get('valid')) {
vmconfig[rec.get('name')] = rec.get('itemId');
}
});
return vmconfig;
},
checkValidity: function() {
let me = this;
let valid = me.lookup('grid').getStore().findExact('valid', false) === -1;
me.lookup('validationfield').setValue(valid);
},
updateVMConfig: function() {
let me = this;
let view = me.getView();
let grid = me.lookup('grid');
let store = grid.getStore();
let vmconfig = me.getVMConfig();
let valid = true;
store.each((rec) => {
let itemId = rec.get('itemId');
let name = rec.get('name');
let panel = view.getComponent(itemId);
if (!panel) {
throw "unexpected missing panel";
}
// copy config for each panel and remote its own id
let panel_vmconfig = Ext.apply({}, vmconfig);
if (panel_vmconfig[name] === itemId) {
delete panel_vmconfig[name];
}
if (!rec.get('valid')) {
valid = false;
}
panel.updateVMConfig(panel_vmconfig);
});
me.lookup('validationfield').setValue(valid);
return vmconfig;
},
onChange: function(panel, newVal) {
let me = this;
let store = me.lookup('grid').getStore();
let el = store.findRecord('itemId', panel.itemId, 0, false, true, true);
if (el.get('name') === newVal) {
// do not update if there was no change
return;
}
el.set('name', newVal);
el.commit();
store.sort(me.diskSorter);
// so that it happens after the layouting
setTimeout(function() {
me.updateVMConfig();
}, 10);
},
onRemove: function(tableview, rowIndex, colIndex, item, event, record) {
let me = this;
let grid = me.lookup('grid');
let store = grid.getStore();
let removed_idx = store.indexOf(record);
let selection = grid.getSelection()[0];
let selected_idx = store.indexOf(selection);
if (selected_idx === removed_idx) {
let newidx = store.getCount() > removed_idx + 1 ? removed_idx + 1: removed_idx - 1;
grid.getSelectionModel().select(newidx, false);
}
store.remove(record);
me.getView().remove(record.get('itemId'));
me.lookup('addButton').setDisabled(false);
me.updateVMConfig();
me.checkValidity();
},
onSelectionChange: function(grid, selection) {
let me = this;
if (!selection || selection.length < 1) {
return;
}
me.getView().setActiveItem(selection[0].data.itemId);
},
control: {
'inputpanel': {
diskidchange: 'onChange',
},
'grid[reference=grid]': {
selectionchange: 'onSelectionChange',
},
},
init: function(view) {
let me = this;
me.onAdd();
me.lookup('grid').getSelectionModel().select(0, false);
},
},
dockedItems: [
{
xtype: 'container',
layout: {
type: 'vbox',
align: 'stretch',
},
dock: 'left',
border: false,
width: 130,
items: [
{
xtype: 'grid',
hideHeaders: true,
reference: 'grid',
flex: 1,
emptyText: gettext('No Disks'),
margin: '0 0 5 0',
store: {
fields: ['name', 'itemId', 'valid'],
data: [],
},
columns: [
{
dataIndex: 'name',
renderer: function(val, md, rec) {
let warn = '';
if (!rec.get('valid')) {
warn = ' ';
status += `
`;
status += `
`;
status += '
${status}${info.text} `;
info.text += PVE.Utils.renderTags(info.tags, PVE.UIOptions.tagOverrides);
},
getToolTip: function(info) {
if (info.type === 'pool' || info.groupbyid !== undefined) {
return undefined;
}
let qtips = [gettext('Status') + ': ' + (info.qmpstatus || info.status)];
if (info.lock) {
qtips.push(Ext.String.format(gettext('Config locked ({0})'), info.lock));
}
if (info.hastate !== 'unmanaged') {
qtips.push(gettext('HA State') + ": " + info.hastate);
}
if (info.type === 'storage') {
let usage = info.disk / info.maxdisk;
if (usage >= 0.0 && usage <= 1.0) {
qtips.push(Ext.String.format(gettext("Usage: {0}%"), (usage*100).toFixed(2)));
}
}
let tip = qtips.join(', ');
info.tip = tip;
return tip;
},
// private
addChildSorted: function(node, info) {
let me = this;
me.setIconCls(info);
me.setText(info);
if (info.groupbyid) {
info.text = info.groupbyid;
if (info.type === 'type') {
let defaults = PVE.tree.ResourceTree.typeDefaults[info.groupbyid];
if (defaults && defaults.text) {
info.text = defaults.text;
}
}
}
let child = Ext.create('PVETree', info);
if (node.childNodes) {
let pos = me.findInsertIndex(node, child, 0, node.childNodes.length);
node.insertBefore(child, node.childNodes[pos]);
} else {
node.insertBefore(child);
}
return child;
},
// private
groupChild: function(node, info, groups, level) {
let me = this;
let groupBy = groups[level];
let v = info[groupBy];
if (v) {
let group = node.findChild('groupbyid', v);
if (!group) {
let groupinfo;
if (info.type === groupBy) {
groupinfo = info;
} else {
groupinfo = {
type: groupBy,
id: groupBy + "/" + v,
};
if (groupBy !== 'type') {
groupinfo[groupBy] = v;
}
}
groupinfo.leaf = false;
groupinfo.groupbyid = v;
group = me.addChildSorted(node, groupinfo);
}
if (info.type === groupBy) {
return group;
}
if (group) {
return me.groupChild(group, info, groups, level + 1);
}
}
return me.addChildSorted(node, info);
},
saveSortingOptions: function() {
let me = this;
let changed = false;
for (const key of ['sort-field', 'group-templates', 'group-guest-types']) {
let newValue = PVE.UIOptions.getTreeSortingValue(key);
if (me[key] !== newValue) {
me[key] = newValue;
changed = true;
}
}
return changed;
},
initComponent: function() {
let me = this;
me.saveSortingOptions();
let rstore = PVE.data.ResourceStore;
let sp = Ext.state.Manager.getProvider();
if (!me.viewFilter) {
me.viewFilter = {};
}
let pdata = {
dataIndex: {},
updateCount: 0,
};
let store = Ext.create('Ext.data.TreeStore', {
model: 'PVETree',
root: {
expanded: true,
id: 'root',
text: gettext('Datacenter'),
iconCls: 'fa fa-server',
},
});
let stateid = 'rid';
const changedFields = [
'text', 'running', 'template', 'status', 'qmpstatus', 'hastate', 'lock', 'tags',
];
let updateTree = function() {
store.suspendEvents();
let rootnode = me.store.getRootNode();
// remember selected node (and all parents)
let sm = me.getSelectionModel();
let lastsel = sm.getSelection()[0];
let parents = [];
let sorting_changed = me.saveSortingOptions();
for (let node = lastsel; node; node = node.parentNode) {
parents.push(node);
}
let groups = me.viewFilter.groups || [];
// explicitly check for node/template, as those are not always grouping attributes
// also check for name for when the tree is sorted by name
let moveCheckAttrs = groups.concat(['node', 'template', 'name']);
let filterfn = me.viewFilter.filterfn;
let reselect = false; // for disappeared nodes
let index = pdata.dataIndex;
// remove vanished or moved items and update changed items in-place
for (const [key, olditem] of Object.entries(index)) {
// getById() use find(), which is slow (ExtJS4 DP5)
let item = rstore.data.get(olditem.data.id);
let changed = sorting_changed, moved = sorting_changed;
if (item) {
// test if any grouping attributes changed, catches migrated tree-nodes in server view too
for (const attr of moveCheckAttrs) {
if (item.data[attr] !== olditem.data[attr]) {
moved = true;
break;
}
}
// tree item has been updated
for (const field of changedFields) {
if (item.data[field] !== olditem.data[field]) {
changed = true;
break;
}
}
// FIXME: also test filterfn()?
}
if (changed) {
olditem.beginEdit();
let info = olditem.data;
Ext.apply(info, item.data);
me.setIconCls(info);
me.setText(info);
olditem.commit();
}
if ((!item || moved) && olditem.isLeaf()) {
delete index[key];
let parentNode = olditem.parentNode;
// a selected item moved (migration) or disappeared (destroyed), so deselect that
// node now and try to reselect the moved (or its parent) node later
if (lastsel && olditem.data.id === lastsel.data.id) {
reselect = true;
sm.deselect(olditem);
}
// store events are suspended, so remove the item manually
store.remove(olditem);
parentNode.removeChild(olditem, true);
}
}
rstore.each(function(item) { // add new items
let olditem = index[item.data.id];
if (olditem) {
return;
}
if (filterfn && !filterfn(item)) {
return;
}
let info = Ext.apply({ leaf: true }, item.data);
let child = me.groupChild(rootnode, info, groups, 0);
if (child) {
index[item.data.id] = child;
}
});
store.resumeEvents();
store.fireEvent('refresh', store);
// select parent node if original selected node vanished
if (lastsel && !rootnode.findChild('id', lastsel.data.id, true)) {
lastsel = rootnode;
for (const node of parents) {
if (rootnode.findChild('id', node.data.id, true)) {
lastsel = node;
break;
}
}
me.selectById(lastsel.data.id);
} else if (lastsel && reselect) {
me.selectById(lastsel.data.id);
}
// on first tree load set the selection from the stateful provider
if (!pdata.updateCount) {
rootnode.expand();
me.applyState(sp.get(stateid));
}
pdata.updateCount++;
};
sp.on('statechange', (_sp, key, value) => {
if (key === stateid) {
me.applyState(value);
}
});
Ext.apply(me, {
allowSelection: true,
store: store,
viewConfig: {
animate: false, // note: animate cause problems with applyState
},
listeners: {
itemcontextmenu: PVE.Utils.createCmdMenu,
destroy: function() {
rstore.un("load", updateTree);
},
beforecellmousedown: function(tree, td, cellIndex, record, tr, rowIndex, ev) {
let sm = me.getSelectionModel();
// disable selection when right clicking except if the record is already selected
me.allowSelection = ev.button !== 2 || sm.isSelected(record);
},
beforeselect: function(tree, record, index, eopts) {
let allow = me.allowSelection;
me.allowSelection = true;
return allow;
},
itemdblclick: PVE.Utils.openTreeConsole,
afterrender: function() {
if (me.tip) {
return;
}
let selectors = [
'.x-tree-node-text > span:not(.proxmox-tag-dark):not(.proxmox-tag-light)',
'.x-tree-icon',
];
me.tip = Ext.create('Ext.tip.ToolTip', {
target: me.el,
delegate: selectors.join(', '),
trackMouse: true,
renderTo: Ext.getBody(),
listeners: {
beforeshow: function(tip) {
let rec = me.getView().getRecord(tip.triggerElement);
let tipText = me.getToolTip(rec.data);
if (tipText) {
tip.update(tipText);
return true;
}
return false;
},
},
});
},
},
setViewFilter: function(view) {
me.viewFilter = view;
me.clearTree();
updateTree();
},
setDatacenterText: function(clustername) {
let rootnode = me.store.getRootNode();
let rnodeText = gettext('Datacenter');
if (clustername !== undefined) {
rnodeText += ' (' + clustername + ')';
}
rootnode.beginEdit();
rootnode.data.text = rnodeText;
rootnode.commit();
},
clearTree: function() {
pdata.updateCount = 0;
let rootnode = me.store.getRootNode();
rootnode.collapse();
rootnode.removeAll();
pdata.dataIndex = {};
me.getSelectionModel().deselectAll();
},
selectExpand: function(node) {
let sm = me.getSelectionModel();
if (!sm.isSelected(node)) {
sm.select(node);
for (let iter = node; iter; iter = iter.parentNode) {
if (!iter.isExpanded()) {
iter.expand();
}
}
me.getView().focusRow(node);
}
},
selectById: function(nodeid) {
let rootnode = me.store.getRootNode();
let node;
if (nodeid === 'root') {
node = rootnode;
} else {
node = rootnode.findChild('id', nodeid, true);
}
if (node) {
me.selectExpand(node);
}
return node;
},
applyState: function(state) {
if (state && state.value) {
me.selectById(state.value);
} else {
me.getSelectionModel().deselectAll();
}
},
});
me.callParent();
me.getSelectionModel().on('select', (_sm, n) => sp.set(stateid, { value: n.data.id }));
rstore.on("load", updateTree);
rstore.startUpdate();
},
});
Ext.define('PVE.guest.SnapshotTree', {
extend: 'Ext.tree.Panel',
xtype: 'pveGuestSnapshotTree',
stateful: true,
stateId: 'grid-snapshots',
viewModel: {
data: {
// should be 'qemu' or 'lxc'
type: undefined,
nodename: undefined,
vmid: undefined,
snapshotAllowed: false,
rollbackAllowed: false,
snapshotFeature: false,
running: false,
selected: '',
load_delay: 3000,
},
formulas: {
canSnapshot: (get) => get('snapshotAllowed') && get('snapshotFeature'),
canRollback: (get) => get('rollbackAllowed') && get('isSnapshot'),
canRemove: (get) => get('snapshotAllowed') && get('isSnapshot'),
isSnapshot: (get) => get('selected') && get('selected') !== 'current',
buttonText: (get) => get('snapshotAllowed') ? gettext('Edit') : gettext('View'),
showMemory: (get) => get('type') === 'qemu',
},
},
controller: {
xclass: 'Ext.app.ViewController',
newSnapshot: function() {
this.run_editor(false);
},
editSnapshot: function() {
this.run_editor(true);
},
run_editor: function(edit) {
let me = this;
let vm = me.getViewModel();
let snapname;
if (edit) {
snapname = vm.get('selected');
if (!snapname || snapname === 'current') { return; }
}
let win = Ext.create('PVE.window.Snapshot', {
nodename: vm.get('nodename'),
vmid: vm.get('vmid'),
viewonly: !vm.get('snapshotAllowed'),
type: vm.get('type'),
isCreate: !edit,
submitText: !edit ? gettext('Take Snapshot') : undefined,
snapname: snapname,
running: vm.get('running'),
});
win.show();
me.mon(win, 'destroy', me.reload, me);
},
snapshotAction: function(action, method) {
let me = this;
let view = me.getView();
let vm = me.getViewModel();
let snapname = vm.get('selected');
if (!snapname) { return; }
let nodename = vm.get('nodename');
let type = vm.get('type');
let vmid = vm.get('vmid');
Proxmox.Utils.API2Request({
url: `/nodes/${nodename}/${type}/${vmid}/snapshot/${snapname}/${action}`,
method: method,
waitMsgTarget: view,
callback: function() {
me.reload();
},
failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
},
success: function(response, options) {
var upid = response.result.data;
var win = Ext.create('Proxmox.window.TaskProgress', { upid: upid });
win.show();
},
});
},
rollback: function() {
this.snapshotAction('rollback', 'POST');
},
remove: function() {
this.snapshotAction('', 'DELETE');
},
cancel: function() {
this.load_task.cancel();
},
reload: function() {
let me = this;
let view = me.getView();
let vm = me.getViewModel();
let nodename = vm.get('nodename');
let vmid = vm.get('vmid');
let type = vm.get('type');
let load_delay = vm.get('load_delay');
Proxmox.Utils.API2Request({
url: `/nodes/${nodename}/${type}/${vmid}/snapshot`,
method: 'GET',
failure: function(response, opts) {
if (me.destroyed) return;
Proxmox.Utils.setErrorMask(view, response.htmlStatus);
me.load_task.delay(load_delay);
},
success: function(response, opts) {
if (me.destroyed) {
// this is in a delayed task, avoid dragons if view has
// been destroyed already and go home.
return;
}
Proxmox.Utils.setErrorMask(view, false);
var digest = 'invalid';
var idhash = {};
var root = { name: '__root', expanded: true, children: [] };
Ext.Array.each(response.result.data, function(item) {
item.leaf = true;
item.children = [];
if (item.name === 'current') {
vm.set('running', !!item.running);
digest = item.digest + item.running;
item.iconCls = PVE.Utils.get_object_icon_class(vm.get('type'), item);
} else {
item.iconCls = 'fa fa-fw fa-history x-fa-tree';
}
idhash[item.name] = item;
});
if (digest !== me.old_digest) {
me.old_digest = digest;
Ext.Array.each(response.result.data, function(item) {
if (item.parent && idhash[item.parent]) {
var parent_item = idhash[item.parent];
parent_item.children.push(item);
parent_item.leaf = false;
parent_item.expanded = true;
parent_item.expandable = false;
} else {
root.children.push(item);
}
});
me.getView().setRootNode(root);
}
me.load_task.delay(load_delay);
},
});
// if we do not have the permissions, we don't have to check
// if we can create a snapshot, since the butten stays disabled
if (!vm.get('snapshotAllowed')) {
return;
}
Proxmox.Utils.API2Request({
url: `/nodes/${nodename}/${type}/${vmid}/feature`,
params: { feature: 'snapshot' },
method: 'GET',
success: function(response, options) {
if (me.destroyed) {
// this is in a delayed task, the current view could been
// destroyed already; then we mustn't do viemodel set
return;
}
let res = response.result.data;
vm.set('snapshotFeature', !!res.hasFeature);
},
});
},
select: function(grid, val) {
let vm = this.getViewModel();
if (val.length < 1) {
vm.set('selected', '');
return;
}
vm.set('selected', val[0].data.name);
},
init: function(view) {
let me = this;
let vm = me.getViewModel();
me.load_task = new Ext.util.DelayedTask(me.reload, me);
if (!view.type) {
throw 'guest type not set';
}
vm.set('type', view.type);
if (!view.pveSelNode.data.node) {
throw "no node name specified";
}
vm.set('nodename', view.pveSelNode.data.node);
if (!view.pveSelNode.data.vmid) {
throw "no VM ID specified";
}
vm.set('vmid', view.pveSelNode.data.vmid);
let caps = Ext.state.Manager.get('GuiCap');
vm.set('snapshotAllowed', !!caps.vms['VM.Snapshot']);
vm.set('rollbackAllowed', !!caps.vms['VM.Snapshot.Rollback']);
view.getStore().sorters.add({
property: 'order',
direction: 'ASC',
});
me.reload();
},
},
listeners: {
selectionchange: 'select',
itemdblclick: 'editSnapshot',
beforedestroy: 'cancel',
},
layout: 'fit',
rootVisible: false,
animate: false,
sortableColumns: false,
tbar: [
{
xtype: 'proxmoxButton',
text: gettext('Take Snapshot'),
disabled: true,
bind: {
disabled: "{!canSnapshot}",
},
handler: 'newSnapshot',
},
'-',
{
xtype: 'proxmoxButton',
text: gettext('Rollback'),
disabled: true,
bind: {
disabled: '{!canRollback}',
},
confirmMsg: function() {
let view = this.up('treepanel');
let rec = view.getSelection()[0];
let vmid = view.getViewModel().get('vmid');
return Proxmox.Utils.format_task_description('qmrollback', vmid) +
` '${rec.data.name}'? ${gettext("Current state will be lost.")}`;
},
handler: 'rollback',
},
'-',
{
xtype: 'proxmoxButton',
text: gettext('Edit'),
bind: {
text: '{buttonText}',
disabled: '{!isSnapshot}',
},
disabled: true,
edit: true,
handler: 'editSnapshot',
},
{
xtype: 'proxmoxButton',
text: gettext('Remove'),
disabled: true,
dangerous: true,
bind: {
disabled: '{!canRemove}',
},
confirmMsg: function() {
let view = this.up('treepanel');
let { data } = view.getSelection()[0];
return Ext.String.format(gettext('Are you sure you want to remove entry {0}'), `'${data.name}'`);
},
handler: 'remove',
},
{
xtype: 'label',
text: gettext("The current guest configuration does not support taking new snapshots"),
hidden: true,
bind: {
hidden: "{canSnapshot}",
},
},
],
columnLines: true,
fields: [
'name',
'description',
'snapstate',
'vmstate',
'running',
{ name: 'snaptime', type: 'date', dateFormat: 'timestamp' },
{
name: 'order',
calculate: function(data) {
return data.snaptime || (data.name === 'current' ? 'ZZZ' : data.snapstate);
},
},
],
columns: [
{
xtype: 'treecolumn',
text: gettext('Name'),
dataIndex: 'name',
width: 200,
renderer: (value, _, { data }) => data.name !== 'current' ? value : gettext('NOW'),
},
{
text: gettext('RAM'),
hidden: true,
bind: {
hidden: '{!showMemory}',
},
align: 'center',
resizable: false,
dataIndex: 'vmstate',
width: 50,
renderer: (value, _, { data }) => data.name !== 'current' ? Proxmox.Utils.format_boolean(value) : '',
},
{
text: gettext('Date') + "/" + gettext("Status"),
dataIndex: 'snaptime',
width: 150,
renderer: function(value, metaData, record) {
if (record.data.snapstate) {
return record.data.snapstate;
} else if (value) {
return Ext.Date.format(value, 'Y-m-d H:i:s');
}
return '';
},
},
{
text: gettext('Description'),
dataIndex: 'description',
flex: 1,
renderer: function(value, metaData, record) {
if (record.data.name === 'current') {
return gettext("You are here!");
} else {
return Ext.String.htmlEncode(value);
}
},
},
],
});
Ext.define('PVE.tree.ResourceMapTree', {
extend: 'Ext.tree.Panel',
alias: 'widget.pveResourceMapTree',
mixins: ['Proxmox.Mixin.CBind'],
rootVisible: false,
emptyText: gettext('No Mapping found'),
// will be opened on edit
editWindowClass: undefined,
// The base url of the resource
baseUrl: undefined,
// icon class to show on the entries
mapIconCls: undefined,
// if given, should be a function that takes a nodename and returns
// the url for getting the data to check the status
getStatusCheckUrl: undefined,
// the result of above api call and the nodename is passed and can set the status
checkValidity: undefined,
// the property that denotes a single map entry for a node
entryIdProperty: undefined,
cbindData: function(initialConfig) {
let me = this;
const caps = Ext.state.Manager.get('GuiCap');
me.canConfigure = !!caps.mapping['Mapping.Modify'];
return {};
},
controller: {
xclass: 'Ext.app.ViewController',
addMapping: function() {
let me = this;
let view = me.getView();
Ext.create(view.editWindowClass, {
url: view.baseUrl,
autoShow: true,
listeners: {
destroy: () => me.load(),
},
});
},
add: function(_grid, _rI, _cI, _item, _e, rec) {
let me = this;
if (rec.data.type !== 'entry') {
return;
}
me.openMapEditWindow(rec.data.name);
},
editDblClick: function() {
let me = this;
let view = me.getView();
let selection = view.getSelection();
if (!selection || selection.length < 1) {
return;
}
me.edit(selection[0]);
},
editAction: function(_grid, _rI, _cI, _item, _e, rec) {
this.edit(rec);
},
edit: function(rec) {
let me = this;
if (rec.data.type === 'map') {
return;
}
me.openMapEditWindow(rec.data.name, rec.data.node, rec.data.type === 'entry');
},
openMapEditWindow: function(name, nodename, entryOnly) {
let me = this;
let view = me.getView();
Ext.create(view.editWindowClass, {
url: `${view.baseUrl}/${name}`,
autoShow: true,
autoLoad: true,
entryOnly,
nodename,
name,
listeners: {
destroy: () => me.load(),
},
});
},
remove: function(_grid, _rI, _cI, _item, _e, rec) {
let me = this;
let msg, id;
let view = me.getView();
let confirmMsg;
switch (rec.data.type) {
case 'entry':
msg = gettext("Are you sure you want to remove '{0}'");
confirmMsg = Ext.String.format(msg, rec.data.name);
break;
case 'node':
msg = gettext("Are you sure you want to remove '{0}' entries for '{1}'");
confirmMsg = Ext.String.format(msg, rec.data.node, rec.data.name);
break;
case 'map':
msg = gettext("Are you sure you want to remove '{0}' on '{1}' for '{2}'");
id = rec.data[view.entryIdProperty];
confirmMsg = Ext.String.format(msg, id, rec.data.node, rec.data.name);
break;
default:
throw "invalid type";
}
Ext.Msg.confirm(gettext('Confirm'), confirmMsg, function(btn) {
if (btn === 'yes') {
me.executeRemove(rec.data);
}
});
},
executeRemove: function(data) {
let me = this;
let view = me.getView();
let url = `${view.baseUrl}/${data.name}`;
let method = 'PUT';
let params = {
digest: me.lookup[data.name].digest,
};
let map = me.lookup[data.name].map;
switch (data.type) {
case 'entry':
method = 'DELETE';
params = undefined;
break;
case 'node':
params.map = PVE.Parser.filterPropertyStringList(map, (e) => e.node !== data.node);
break;
case 'map':
params.map = PVE.Parser.filterPropertyStringList(map, (e) =>
Object.entries(e).some(([key, value]) => data[key] !== value));
break;
default:
throw "invalid type";
}
if (!params?.map.length) {
method = 'DELETE';
params = undefined;
}
Proxmox.Utils.API2Request({
url,
method,
params,
success: function() {
me.load();
},
});
},
load: function() {
let me = this;
let view = me.getView();
Proxmox.Utils.API2Request({
url: view.baseUrl,
method: 'GET',
failure: response => Ext.Msg.alert(gettext('Error'), response.htmlStatus),
success: function({ result: { data } }) {
let lookup = {};
data.forEach((entry) => {
lookup[entry.id] = Ext.apply({}, entry);
entry.iconCls = 'fa fa-fw fa-folder-o';
entry.name = entry.id;
entry.text = entry.id;
entry.type = 'entry';
let nodes = {};
for (const map of entry.map) {
let parsed = PVE.Parser.parsePropertyString(map);
parsed.iconCls = view.mapIconCls;
parsed.leaf = true;
parsed.name = entry.id;
parsed.text = parsed[view.entryIdProperty];
parsed.type = 'map';
if (nodes[parsed.node] === undefined) {
nodes[parsed.node] = {
children: [],
expanded: true,
iconCls: 'fa fa-fw fa-building-o',
leaf: false,
name: entry.id,
node: parsed.node,
text: parsed.node,
type: 'node',
};
}
nodes[parsed.node].children.push(parsed);
}
delete entry.id;
entry.children = Object.values(nodes);
entry.leaf = entry.children.length === 0;
});
me.lookup = lookup;
if (view.getStatusCheckUrl !== undefined && view.checkValidity !== undefined) {
me.loadStatusData();
}
view.setRootNode({
children: data,
});
let root = view.getRootNode();
root.expand();
root.childNodes.forEach(node => node.expand());
},
});
},
nodeLoadingState: {},
loadStatusData: function() {
let me = this;
let view = me.getView();
PVE.data.ResourceStore.getNodes().forEach(({ node }) => {
me.nodeLoadingState[node] = true;
let url = view.getStatusCheckUrl(node);
Proxmox.Utils.API2Request({
url,
method: 'GET',
failure: function(response) {
me.nodeLoadingState[node] = false;
view.getRootNode()?.cascade(function(rec) {
if (rec.data.node !== node) {
return;
}
rec.set('valid', 0);
rec.set('errmsg', response.htmlStatus);
rec.commit();
});
},
success: function({ result: { data } }) {
me.nodeLoadingState[node] = false;
view.checkValidity(data, node);
},
});
});
},
renderStatus: function(value, _metadata, record) {
let me = this;
if (record.data.type !== 'map') {
return '';
}
let iconCls;
let status;
if (value === undefined) {
if (me.nodeLoadingState[record.data.node]) {
iconCls = 'fa-spinner fa-spin';
status = gettext('Loading...');
} else {
iconCls = 'fa-question-circle';
status = gettext('Unknown Node');
}
} else {
let state = value ? 'good' : 'critical';
iconCls = PVE.Utils.get_health_icon(state, true);
status = value ? gettext("Mapping matches host data") : record.data.errmsg || Proxmox.Utils.unknownText;
}
return `{{${v}}}`).join(', '),
),
},
{
xtype: 'label',
name: 'pruneLabel',
text: gettext('Storage Retention Configuration') + ':',
hidden: true,
},
{
layout: 'hbox',
border: false,
defaults: {
border: false,
layout: 'anchor',
flex: 1,
},
items: [
{
padding: '0 10 0 0',
defaults: {
labelWidth: 110,
},
items: [
pruneSettings[0],
pruneSettings[2],
pruneSettings[4],
],
},
{
padding: '0 0 0 10',
defaults: {
labelWidth: 110,
},
items: [
pruneSettings[1],
pruneSettings[3],
pruneSettings[5],
],
},
],
},
],
});
var submitBtn = Ext.create('Ext.Button', {
text: gettext('Backup'),
handler: function() {
var storage = storagesel.getValue();
let values = me.formPanel.getValues();
var params = {
storage: storage,
vmid: me.vmid,
mode: values.mode,
remove: values.remove,
};
if (values.mailto) {
params.mailto = values.mailto;
}
if (values['notification-mode']) {
params['notification-mode'] = values['notification-mode'];
}
if (values.compress) {
params.compress = values.compress;
}
if (values.protected) {
params.protected = values.protected;
}
if (values['notes-template']) {
params['notes-template'] = PVE.Utils.escapeNotesTemplate(
values['notes-template']);
}
Proxmox.Utils.API2Request({
url: '/nodes/' + me.nodename + '/vzdump',
params: params,
method: 'POST',
failure: function(response, opts) {
Ext.Msg.alert('Error', response.htmlStatus);
},
success: function(response, options) {
// close later so we reload the grid
// after the task has completed
me.hide();
var upid = response.result.data;
var win = Ext.create('Proxmox.window.TaskViewer', {
upid: upid,
listeners: {
close: function() {
me.close();
},
},
});
win.show();
},
});
},
});
var helpBtn = Ext.create('Proxmox.button.Help', {
onlineHelp: 'chapter_vzdump',
listenToGlobalEvent: false,
hidden: false,
});
var title = gettext('Backup') + " " +
(me.vmtype === 'lxc' ? "CT" : "VM") +
" " + me.vmid;
Ext.apply(me, {
title: title,
modal: true,
layout: 'auto',
border: false,
width: 600,
items: [me.formPanel],
buttons: [helpBtn, '->', submitBtn],
listeners: {
afterrender: function() {
/// cleared within the storage selector's change listener
me.setLoading(gettext('Please wait...'));
storagesel.setValue(me.storage);
},
},
});
me.callParent();
},
});
Ext.define('PVE.window.BackupConfig', {
extend: 'Ext.window.Window',
title: gettext('Configuration'),
width: 600,
height: 400,
layout: 'fit',
modal: true,
items: {
xtype: 'component',
itemId: 'configtext',
autoScroll: true,
style: {
'white-space': 'pre',
'font-family': 'monospace',
padding: '5px',
},
},
initComponent: function() {
var me = this;
if (!me.volume) {
throw "no volume specified";
}
var nodename = me.pveSelNode.data.node;
if (!nodename) {
throw "no node name specified";
}
me.callParent();
Proxmox.Utils.API2Request({
url: "/nodes/" + nodename + "/vzdump/extractconfig",
method: 'GET',
params: {
volume: me.volume,
},
failure: function(response, opts) {
me.close();
Ext.Msg.alert('Error', response.htmlStatus);
},
success: function(response, options) {
me.show();
me.down('#configtext').update(Ext.htmlEncode(response.result.data));
},
});
},
});
Ext.define('PVE.window.BulkAction', {
extend: 'Ext.window.Window',
resizable: true,
width: 800,
height: 600,
modal: true,
layout: {
type: 'fit',
},
border: false,
// the action to set, currently there are: `startall`, `migrateall`, `stopall`, `suspendall`
action: undefined,
submit: function(params) {
let me = this;
Proxmox.Utils.API2Request({
params: params,
url: `/nodes/${me.nodename}/${me.action}`,
waitMsgTarget: me,
method: 'POST',
failure: response => Ext.Msg.alert('Error', response.htmlStatus),
success: function({ result }, options) {
Ext.create('Proxmox.window.TaskViewer', {
autoShow: true,
upid: result.data,
listeners: {
destroy: () => me.close(),
},
});
me.hide();
},
});
},
initComponent: function() {
let me = this;
if (!me.nodename) {
throw "no node name specified";
}
if (!me.action) {
throw "no action specified";
}
if (!me.btnText) {
throw "no button text specified";
}
if (!me.title) {
throw "no title specified";
}
let items = [];
if (me.action === 'migrateall') {
items.push(
{
xtype: 'fieldcontainer',
layout: 'hbox',
items: [{
flex: 1,
xtype: 'pveNodeSelector',
name: 'target',
disallowedNodes: [me.nodename],
fieldLabel: gettext('Target node'),
labelWidth: 200,
allowBlank: false,
onlineValidator: true,
padding: '0 10 0 0',
},
{
xtype: 'proxmoxintegerfield',
name: 'maxworkers',
minValue: 1,
maxValue: 100,
value: 1,
fieldLabel: gettext('Parallel jobs'),
allowBlank: false,
flex: 1,
}],
},
{
xtype: 'fieldcontainer',
layout: 'hbox',
items: [{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Allow local disk migration'),
name: 'with-local-disks',
labelWidth: 200,
checked: true,
uncheckedValue: 0,
flex: 1,
padding: '0 10 0 0',
},
{
itemId: 'lxcwarning',
xtype: 'displayfield',
userCls: 'pmx-hint',
value: 'Warning: Running CTs will be migrated in Restart Mode.',
hidden: true, // only visible if running container chosen
flex: 1,
}],
},
);
} else if (me.action === 'startall') {
items.push({
xtype: 'hiddenfield',
name: 'force',
value: 1,
});
} else if (me.action === 'stopall') {
items.push({
xtype: 'fieldcontainer',
layout: 'hbox',
items: [{
xtype: 'proxmoxcheckbox',
name: 'force-stop',
labelWidth: 120,
fieldLabel: gettext('Force Stop'),
boxLabel: gettext('Force stop guest if shutdown times out.'),
checked: true,
uncheckedValue: 0,
flex: 1,
},
{
xtype: 'proxmoxintegerfield',
name: 'timeout',
fieldLabel: gettext('Timeout (s)'),
labelWidth: 120,
emptyText: '180',
minValue: 0,
maxValue: 7200,
allowBlank: true,
flex: 1,
}],
});
}
let refreshLxcWarning = function(vmids, records) {
let showWarning = records.some(
item => vmids.includes(item.data.vmid) && item.data.type === 'lxc' && item.data.status === 'running',
);
me.down('#lxcwarning').setVisible(showWarning);
};
let defaultStatus = me.action === 'migrateall' ? '' : me.action === 'startall' ? 'stopped' : 'running';
let defaultType = me.action === 'suspendall' ? 'qemu' : '';
let statusMap = [];
let poolMap = [];
let haMap = [];
let tagMap = [];
PVE.data.ResourceStore.each((rec) => {
if (['qemu', 'lxc'].indexOf(rec.data.type) !== -1) {
statusMap[rec.data.status] = true;
}
if (rec.data.type === 'pool') {
poolMap[rec.data.pool] = true;
}
if (rec.data.hastate !== "") {
haMap[rec.data.hastate] = true;
}
if (rec.data.tags !== "") {
rec.data.tags.split(/[,; ]/).forEach((tag) => {
if (tag !== '') {
tagMap[tag] = true;
}
});
}
});
let statusList = Object.keys(statusMap).map(key => [key, key]);
statusList.unshift(['', gettext('All')]);
let poolList = Object.keys(poolMap).map(key => [key, key]);
let tagList = Object.keys(tagMap).map(key => ({ value: key }));
let haList = Object.keys(haMap).map(key => [key, key]);
let clearFilters = function() {
me.down('#namefilter').setValue('');
['name', 'status', 'pool', 'type', 'hastate', 'includetag', 'excludetag', 'vmid'].forEach((filter) => {
me.down(`#${filter}filter`).setValue('');
});
};
let filterChange = function() {
let nameValue = me.down('#namefilter').getValue();
let filterCount = 0;
if (nameValue !== '') {
filterCount++;
}
let arrayFiltersData = [];
['pool', 'hastate'].forEach((filter) => {
let selected = me.down(`#${filter}filter`).getValue() ?? [];
if (selected.length) {
filterCount++;
arrayFiltersData.push([filter, [...selected]]);
}
});
let singleFiltersData = [];
['status', 'type'].forEach((filter) => {
let selected = me.down(`#${filter}filter`).getValue() ?? '';
if (selected.length) {
filterCount++;
singleFiltersData.push([filter, selected]);
}
});
let includeTags = me.down('#includetagfilter').getValue() ?? [];
if (includeTags.length) {
filterCount++;
}
let excludeTags = me.down('#excludetagfilter').getValue() ?? [];
if (excludeTags.length) {
filterCount++;
}
let fieldSet = me.down('#filters');
let clearBtn = me.down('#clearBtn');
if (filterCount) {
fieldSet.setTitle(Ext.String.format(gettext('Filters ({0})'), filterCount));
clearBtn.setDisabled(false);
} else {
fieldSet.setTitle(gettext('Filters'));
clearBtn.setDisabled(true);
}
let filterFn = function(value) {
let name = value.data.name.toLowerCase().indexOf(nameValue.toLowerCase()) !== -1;
let arrayFilters = arrayFiltersData.every(([filter, selected]) =>
!selected.length || selected.indexOf(value.data[filter]) !== -1);
let singleFilters = singleFiltersData.every(([filter, selected]) =>
!selected.length || value.data[filter].indexOf(selected) !== -1);
let tags = value.data.tags.split(/[;, ]/).filter(t => !!t);
let includeFilter = !includeTags.length || tags.some(tag => includeTags.indexOf(tag) !== -1);
let excludeFilter = !excludeTags.length || tags.every(tag => excludeTags.indexOf(tag) === -1);
return name && arrayFilters && singleFilters && includeFilter && excludeFilter;
};
let vmselector = me.down('#vms');
vmselector.getStore().setFilters({
id: 'customFilter',
filterFn,
});
vmselector.checkChange();
if (me.action === 'migrateall') {
let records = vmselector.getSelection();
refreshLxcWarning(vmselector.getValue(), records);
}
};
items.push({
xtype: 'fieldset',
itemId: 'filters',
collapsible: true,
title: gettext('Filters'),
layout: 'hbox',
items: [
{
xtype: 'container',
flex: 1,
padding: 5,
layout: {
type: 'vbox',
align: 'stretch',
},
defaults: {
listeners: {
change: filterChange,
},
isFormField: false,
},
items: [
{
fieldLabel: gettext("Name"),
itemId: 'namefilter',
xtype: 'textfield',
},
{
xtype: 'combobox',
itemId: 'statusfilter',
fieldLabel: gettext("Status"),
emptyText: gettext('All'),
editable: false,
value: defaultStatus,
store: statusList,
},
{
xtype: 'combobox',
itemId: 'poolfilter',
fieldLabel: gettext("Pool"),
emptyText: gettext('All'),
editable: false,
multiSelect: true,
store: poolList,
},
],
},
{
xtype: 'container',
layout: {
type: 'vbox',
align: 'stretch',
},
flex: 1,
padding: 5,
defaults: {
listeners: {
change: filterChange,
},
isFormField: false,
},
items: [
{
xtype: 'combobox',
itemId: 'typefilter',
fieldLabel: gettext("Type"),
emptyText: gettext('All'),
editable: false,
value: defaultType,
store: [
['', gettext('All')],
['lxc', gettext('CT')],
['qemu', gettext('VM')],
],
},
{
xtype: 'proxmoxComboGrid',
itemId: 'includetagfilter',
fieldLabel: gettext("Include Tags"),
emptyText: gettext('All'),
editable: false,
multiSelect: true,
valueField: 'value',
displayField: 'value',
listConfig: {
userCls: 'proxmox-tags-full',
columns: [
{
dataIndex: 'value',
flex: 1,
renderer: value =>
PVE.Utils.renderTags(value, PVE.UIOptions.tagOverrides),
},
],
},
store: {
data: tagList,
},
listeners: {
change: filterChange,
},
},
{
xtype: 'proxmoxComboGrid',
itemId: 'excludetagfilter',
fieldLabel: gettext("Exclude Tags"),
emptyText: gettext('None'),
multiSelect: true,
editable: false,
valueField: 'value',
displayField: 'value',
listConfig: {
userCls: 'proxmox-tags-full',
columns: [
{
dataIndex: 'value',
flex: 1,
renderer: value =>
PVE.Utils.renderTags(value, PVE.UIOptions.tagOverrides),
},
],
},
store: {
data: tagList,
},
listeners: {
change: filterChange,
},
},
],
},
{
xtype: 'container',
layout: {
type: 'vbox',
align: 'stretch',
},
flex: 1,
padding: 5,
defaults: {
listeners: {
change: filterChange,
},
isFormField: false,
},
items: [
{
xtype: 'combobox',
itemId: 'hastatefilter',
fieldLabel: gettext("HA status"),
emptyText: gettext('All'),
multiSelect: true,
editable: false,
store: haList,
listeners: {
change: filterChange,
},
},
{
xtype: 'container',
layout: {
type: 'vbox',
align: 'end',
},
items: [
{
xtype: 'button',
itemId: 'clearBtn',
text: gettext('Clear Filters'),
disabled: true,
handler: clearFilters,
},
],
},
],
},
],
});
items.push({
xtype: 'vmselector',
itemId: 'vms',
name: 'vms',
flex: 1,
height: 300,
selectAll: true,
allowBlank: false,
plugins: '',
nodename: me.nodename,
listeners: {
selectionchange: function(vmselector, records) {
if (me.action === 'migrateall') {
let vmids = me.down('#vms').getValue();
refreshLxcWarning(vmids, records);
}
},
},
});
me.formPanel = Ext.create('Ext.form.Panel', {
bodyPadding: 10,
border: false,
layout: {
type: 'vbox',
align: 'stretch',
},
fieldDefaults: {
anchor: '100%',
},
items: items,
});
let form = me.formPanel.getForm();
let submitBtn = Ext.create('Ext.Button', {
text: me.btnText,
handler: function() {
form.isValid();
me.submit(form.getValues());
},
});
Ext.apply(me, {
items: [me.formPanel],
buttons: [submitBtn],
});
me.callParent();
form.on('validitychange', function() {
let valid = form.isValid();
submitBtn.setDisabled(!valid);
});
form.isValid();
filterChange();
},
});
Ext.define('PVE.ceph.Install', {
extend: 'Ext.window.Window',
xtype: 'pveCephInstallWindow',
mixins: ['Proxmox.Mixin.CBind'],
width: 220,
header: false,
resizable: false,
draggable: false,
modal: true,
nodename: undefined,
shadow: false,
border: false,
bodyBorder: false,
closable: false,
cls: 'install-mask',
bodyCls: 'install-mask',
layout: {
align: 'stretch',
pack: 'center',
type: 'vbox',
},
viewModel: {
data: {
isInstalled: false,
},
formulas: {
buttonText: function(get) {
if (get('isInstalled')) {
return gettext('Configure Ceph');
} else {
return gettext('Install Ceph');
}
},
windowText: function(get) {
if (get('isInstalled')) {
return `
${Ext.String.format(gettext('{0} is not initialized.'), 'Ceph')}
${gettext('You need to create an initial config once.')}
`;
} else {
return '' +
Ext.String.format(gettext('{0} is not installed on this node.'), 'Ceph') + '
';
}
},
},
},
items: [
{
bind: {
html: '{windowText}',
},
border: false,
padding: 5,
bodyCls: 'install-mask',
},
{
xtype: 'button',
bind: {
text: '{buttonText}',
},
viewModel: {},
cbind: {
nodename: '{nodename}',
},
handler: function() {
let view = this.up('pveCephInstallWindow');
let wizzard = Ext.create('PVE.ceph.CephInstallWizard', {
nodename: view.nodename,
});
wizzard.getViewModel().set('isInstalled', this.getViewModel().get('isInstalled'));
wizzard.show();
view.mon(wizzard, 'beforeClose', function() {
view.fireEvent("cephInstallWindowClosed");
view.close();
});
},
},
],
});
Ext.define('PVE.window.Clone', {
extend: 'Ext.window.Window',
resizable: false,
isTemplate: false,
onlineHelp: 'qm_copy_and_clone',
controller: {
xclass: 'Ext.app.ViewController',
control: {
'panel[reference=cloneform]': {
validitychange: 'disableSubmit',
},
},
disableSubmit: function(form) {
this.lookupReference('submitBtn').setDisabled(!form.isValid());
},
},
statics: {
// display a snapshot selector only if needed
wrap: function(nodename, vmid, isTemplate, guestType) {
Proxmox.Utils.API2Request({
url: '/nodes/' + nodename + '/' + guestType + '/' + vmid +'/snapshot',
failure: function(response, opts) {
Ext.Msg.alert('Error', response.htmlStatus);
},
success: function(response, opts) {
var snapshotList = response.result.data;
var hasSnapshots = !(snapshotList.length === 1 &&
snapshotList[0].name === 'current');
Ext.create('PVE.window.Clone', {
nodename: nodename,
guestType: guestType,
vmid: vmid,
isTemplate: isTemplate,
hasSnapshots: hasSnapshots,
}).show();
},
});
},
},
create_clone: function(values) {
var me = this;
var params = { newid: values.newvmid };
if (values.snapname && values.snapname !== 'current') {
params.snapname = values.snapname;
}
if (values.pool) {
params.pool = values.pool;
}
if (values.name) {
if (me.guestType === 'lxc') {
params.hostname = values.name;
} else {
params.name = values.name;
}
}
if (values.target) {
params.target = values.target;
}
if (values.clonemode === 'copy') {
params.full = 1;
if (values.hdstorage) {
params.storage = values.hdstorage;
if (values.diskformat && me.guestType !== 'lxc') {
params.format = values.diskformat;
}
}
}
Proxmox.Utils.API2Request({
params: params,
url: '/nodes/' + me.nodename + '/' + me.guestType + '/' + me.vmid + '/clone',
waitMsgTarget: me,
method: 'POST',
failure: function(response, opts) {
Ext.Msg.alert('Error', response.htmlStatus);
},
success: function(response, options) {
me.close();
},
});
},
// disable the Storage selector when clone mode is linked clone
updateVisibility: function() {
var me = this;
var clonemode = me.lookupReference('clonemodesel').getValue();
var disksel = me.lookup('diskselector');
disksel.setDisabled(clonemode === 'clone');
},
// add to the list of valid nodes each node where
// all the VM disks are available
verifyFeature: function() {
var me = this;
var snapname = me.lookupReference('snapshotsel').getValue();
var clonemode = me.lookupReference('clonemodesel').getValue();
var params = { feature: clonemode };
if (snapname !== 'current') {
params.snapname = snapname;
}
Proxmox.Utils.API2Request({
waitMsgTarget: me,
url: '/nodes/' + me.nodename + '/' + me.guestType + '/' + me.vmid + '/feature',
params: params,
method: 'GET',
failure: function(response, opts) {
me.lookupReference('submitBtn').setDisabled(true);
Ext.Msg.alert('Error', response.htmlStatus);
},
success: function(response, options) {
var res = response.result.data;
me.lookupReference('targetsel').allowedNodes = res.nodes;
me.lookupReference('targetsel').validate();
},
});
},
initComponent: function() {
var me = this;
if (!me.nodename) {
throw "no node name specified";
}
if (!me.vmid) {
throw "no VM ID specified";
}
if (!me.snapname) {
me.snapname = 'current';
}
if (!me.guestType) {
throw "no Guest Type specified";
}
var titletext = me.guestType === 'lxc' ? 'CT' : 'VM';
if (me.isTemplate) {
titletext += ' Template';
}
me.title = "Clone " + titletext + " " + me.vmid;
var col1 = [];
var col2 = [];
col1.push({
xtype: 'pveNodeSelector',
name: 'target',
reference: 'targetsel',
fieldLabel: gettext('Target node'),
selectCurNode: true,
allowBlank: false,
onlineValidator: true,
listeners: {
change: function(f, value) {
me.lookup('diskselector').getComponent('hdstorage').setTargetNode(value);
},
},
});
var modelist = [['copy', gettext('Full Clone')]];
if (me.isTemplate) {
modelist.push(['clone', gettext('Linked Clone')]);
}
col1.push({
xtype: 'pveGuestIDSelector',
name: 'newvmid',
guestType: me.guestType,
value: '',
loadNextFreeID: true,
validateExists: false,
},
{
xtype: 'textfield',
name: 'name',
vtype: 'DnsName',
allowBlank: true,
fieldLabel: me.guestType === 'lxc' ? gettext('Hostname') : gettext('Name'),
},
{
xtype: 'pvePoolSelector',
fieldLabel: gettext('Resource Pool'),
name: 'pool',
value: '',
allowBlank: true,
},
);
col2.push({
xtype: 'proxmoxKVComboBox',
fieldLabel: gettext('Mode'),
name: 'clonemode',
reference: 'clonemodesel',
allowBlank: false,
hidden: !me.isTemplate,
value: me.isTemplate ? 'clone' : 'copy',
comboItems: modelist,
listeners: {
change: function(t, value) {
me.updateVisibility();
me.verifyFeature();
},
},
},
{
xtype: 'PVE.form.SnapshotSelector',
name: 'snapname',
reference: 'snapshotsel',
fieldLabel: gettext('Snapshot'),
nodename: me.nodename,
guestType: me.guestType,
vmid: me.vmid,
hidden: !!(me.isTemplate || !me.hasSnapshots),
disabled: false,
allowBlank: false,
value: me.snapname,
listeners: {
change: function(f, value) {
me.verifyFeature();
},
},
},
{
xtype: 'pveDiskStorageSelector',
reference: 'diskselector',
nodename: me.nodename,
autoSelect: false,
hideSize: true,
hideSelection: true,
storageLabel: gettext('Target Storage'),
allowBlank: true,
storageContent: me.guestType === 'qemu' ? 'images' : 'rootdir',
emptyText: gettext('Same as source'),
disabled: !!me.isTemplate, // because default mode is clone for templates
});
var formPanel = Ext.create('Ext.form.Panel', {
bodyPadding: 10,
reference: 'cloneform',
border: false,
layout: 'hbox',
defaultType: 'container',
fieldDefaults: {
labelWidth: 100,
anchor: '100%',
},
items: [
{
flex: 1,
padding: '0 10 0 0',
layout: 'anchor',
items: col1,
},
{
flex: 1,
padding: '0 0 0 10',
layout: 'anchor',
items: col2,
},
],
});
Ext.apply(me, {
modal: true,
width: 600,
height: 250,
border: false,
layout: 'fit',
buttons: [{
xtype: 'proxmoxHelpButton',
listenToGlobalEvent: false,
hidden: false,
onlineHelp: me.onlineHelp,
},
'->',
{
reference: 'submitBtn',
text: gettext('Clone'),
disabled: true,
handler: function() {
var cloneForm = me.lookupReference('cloneform');
if (cloneForm.isValid()) {
me.create_clone(cloneForm.getValues());
}
},
}],
items: [formPanel],
});
me.callParent();
me.verifyFeature();
},
});
Ext.define('PVE.FirewallEnableEdit', {
extend: 'Proxmox.window.Edit',
alias: ['widget.pveFirewallEnableEdit'],
mixins: ['Proxmox.Mixin.CBind'],
subject: gettext('Firewall'),
cbindData: {
defaultValue: 0,
},
width: 350,
items: [
{
xtype: 'proxmoxcheckbox',
name: 'enable',
uncheckedValue: 0,
cbind: {
defaultValue: '{defaultValue}',
checked: '{defaultValue}',
},
deleteDefaultValue: false,
fieldLabel: gettext('Firewall'),
},
{
xtype: 'displayfield',
name: 'warning',
userCls: 'pmx-hint',
value: gettext('Warning: Firewall still disabled at datacenter level!'),
hidden: true,
},
],
beforeShow: function() {
var me = this;
Proxmox.Utils.API2Request({
url: '/api2/extjs/cluster/firewall/options',
method: 'GET',
failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
},
success: function(response, opts) {
if (!response.result.data.enable) {
me.down('displayfield[name=warning]').setVisible(true);
}
},
});
},
});
Ext.define('PVE.FirewallLograteInputPanel', {
extend: 'Proxmox.panel.InputPanel',
xtype: 'pveFirewallLograteInputPanel',
viewModel: {},
items: [
{
xtype: 'proxmoxcheckbox',
name: 'enable',
reference: 'enable',
fieldLabel: gettext('Enable'),
value: true,
},
{
layout: 'hbox',
border: false,
items: [
{
xtype: 'numberfield',
name: 'rate',
fieldLabel: gettext('Log rate limit'),
minValue: 1,
maxValue: 99,
allowBlank: false,
flex: 2,
value: 1,
},
{
xtype: 'box',
html: '/
',
},
{
xtype: 'proxmoxKVComboBox',
name: 'unit',
comboItems: [
['second', 'second'],
['minute', 'minute'],
['hour', 'hour'],
['day', 'day'],
],
allowBlank: false,
flex: 1,
value: 'second',
},
],
},
{
xtype: 'numberfield',
name: 'burst',
fieldLabel: gettext('Log burst limit'),
minValue: 1,
maxValue: 99,
value: 5,
},
],
onGetValues: function(values) {
let me = this;
let cfg = {
enable: values.enable !== undefined ? 1 : 0,
rate: values.rate + '/' + values.unit,
burst: values.burst,
};
let properties = PVE.Parser.printPropertyString(cfg, undefined);
if (properties === '') {
return { 'delete': 'log_ratelimit' };
}
return { log_ratelimit: properties };
},
setValues: function(values) {
let me = this;
let properties = {};
if (values.log_ratelimit !== undefined) {
properties = PVE.Parser.parsePropertyString(values.log_ratelimit, 'enable');
if (properties.rate) {
var matches = properties.rate.match(/^(\d+)\/(second|minute|hour|day)$/);
if (matches) {
properties.rate = matches[1];
properties.unit = matches[2];
}
}
}
me.callParent([properties]);
},
});
Ext.define('PVE.FirewallLograteEdit', {
extend: 'Proxmox.window.Edit',
xtype: 'pveFirewallLograteEdit',
subject: gettext('Log rate limit'),
items: [{
xtype: 'pveFirewallLograteInputPanel',
}],
autoLoad: true,
});
/*global u2f*/
Ext.define('PVE.window.LoginWindow', {
extend: 'Ext.window.Window',
viewModel: {
data: {
openid: false,
},
formulas: {
button_text: function(get) {
if (get("openid") === true) {
return gettext("Login (OpenID redirect)");
} else {
return gettext("Login");
}
},
},
},
controller: {
xclass: 'Ext.app.ViewController',
onLogon: async function() {
var me = this;
var form = this.lookupReference('loginForm');
var unField = this.lookupReference('usernameField');
var saveunField = this.lookupReference('saveunField');
var view = this.getView();
if (!form.isValid()) {
return;
}
let creds = form.getValues();
if (this.getViewModel().data.openid === true) {
const redirectURL = location.origin;
Proxmox.Utils.API2Request({
url: '/api2/extjs/access/openid/auth-url',
params: {
realm: creds.realm,
"redirect-url": redirectURL,
},
method: 'POST',
success: function(resp, opts) {
window.location = resp.result.data;
},
failure: function(resp, opts) {
Proxmox.Utils.authClear();
form.unmask();
Ext.MessageBox.alert(
gettext('Error'),
gettext('OpenID redirect failed.') + `'+ text +'
';
} else {
return text;
}
},
flex: 1,
},
{
text: 'Keep (reason)',
dataIndex: 'mark',
renderer: function(value, metaData, record) {
if (record.data.mark === 'keep') {
return 'true (' + record.data.keepReason + ')';
} else if (record.data.mark === 'protected') {
return 'true (protected)';
} else if (record.data.mark === 'renamed') {
return 'true (renamed)';
} else {
return 'false';
}
},
flex: 1,
},
],
},
];
me.callParent();
},
});
Ext.define('PVE.window.Prune', {
extend: 'Proxmox.window.Edit',
method: 'DELETE',
submitText: gettext("Prune"),
fieldDefaults: { labelWidth: 130 },
isCreate: true,
initComponent: function() {
var me = this;
if (!me.nodename) {
throw "no nodename specified";
}
if (!me.storage) {
throw "no storage specified";
}
if (!me.backup_type) {
throw "no backup_type specified";
}
if (me.backup_type !== 'qemu' && me.backup_type !== 'lxc') {
throw "unknown backup type: " + me.backup_type;
}
if (!me.backup_id) {
throw "no backup_id specified";
}
let title = Ext.String.format(
gettext("Prune Backups for '{0}' on Storage '{1}'"),
me.backup_type + '/' + me.backup_id,
me.storage,
);
Ext.apply(me, {
url: '/api2/extjs/nodes/' + me.nodename + '/storage/' + me.storage + "/prunebackups",
title: title,
items: [
{
xtype: 'pvePruneInputPanel',
url: '/api2/extjs/nodes/' + me.nodename + '/storage/' + me.storage + "/prunebackups",
backup_type: me.backup_type,
backup_id: me.backup_id,
storage: me.storage,
},
],
});
me.callParent();
},
});
Ext.define('PVE.window.Restore', {
extend: 'Ext.window.Window', // fixme: Proxmox.window.Edit?
resizable: false,
width: 500,
modal: true,
layout: 'auto',
border: false,
controller: {
xclass: 'Ext.app.ViewController',
control: {
'#liveRestore': {
change: function(el, newVal) {
let liveWarning = this.lookupReference('liveWarning');
liveWarning.setHidden(!newVal);
let start = this.lookupReference('start');
start.setDisabled(newVal);
},
},
'form': {
validitychange: function(f, valid) {
this.lookupReference('doRestoreBtn').setDisabled(!valid);
},
},
},
doRestore: function() {
let me = this;
let view = me.getView();
let values = view.down('form').getForm().getValues();
let params = {
vmid: view.vmid || values.vmid,
force: view.vmid ? 1 : 0,
};
if (values.unique) {
params.unique = 1;
}
if (values.start && !values['live-restore']) {
params.start = 1;
}
if (values['live-restore']) {
params['live-restore'] = 1;
}
if (values.storage) {
params.storage = values.storage;
}
['bwlimit', 'cores', 'name', 'memory', 'sockets'].forEach(opt => {
if ((values[opt] ?? '') !== '') {
params[opt] = values[opt];
}
});
if (params.name && view.vmtype === 'lxc') {
params.hostname = params.name;
delete params.name;
}
let confirmMsg;
if (view.vmtype === 'lxc') {
params.ostemplate = view.volid;
params.restore = 1;
if (values.unprivileged !== 'keep') {
params.unprivileged = values.unprivileged;
}
confirmMsg = Proxmox.Utils.format_task_description('vzrestore', params.vmid);
} else if (view.vmtype === 'qemu') {
params.archive = view.volid;
confirmMsg = Proxmox.Utils.format_task_description('qmrestore', params.vmid);
} else {
throw 'unknown VM type';
}
let executeRestore = () => {
Proxmox.Utils.API2Request({
url: `/nodes/${view.nodename}/${view.vmtype}`,
params: params,
method: 'POST',
waitMsgTarget: view,
failure: response => Ext.Msg.alert(gettext('Error'), response.htmlStatus),
success: function(response, options) {
Ext.create('Proxmox.window.TaskViewer', {
autoShow: true,
upid: response.result.data,
});
view.close();
},
});
};
if (view.vmid) {
confirmMsg += `. ${Ext.String.format(
gettext('This will permanently erase current {0} data.'),
view.vmtype === 'lxc' ? 'CT' : 'VM',
)}`;
if (view.vmtype === 'lxc') {
confirmMsg += `${Ext.htmlEncode(data.errors.group)}
`;
metaData.tdAttr = 'data-qwidth=600 data-qtitle="ERROR" data-qtip="' + html + '"';
}
return value;
},
dataIndex: 'group',
},
{
header: gettext('Description'),
flex: 1,
renderer: Ext.String.htmlEncode,
dataIndex: 'comment',
},
],
listeners: {
beforeselect: (grid, record, index, eOpts) => caps.nodes['Sys.Console'],
itemdblclick: run_editor,
},
});
me.callParent();
},
});
Ext.define('PVE.ha.Status', {
extend: 'Ext.panel.Panel',
alias: 'widget.pveHAStatus',
onlineHelp: 'chapter_ha_manager',
layout: {
type: 'vbox',
align: 'stretch',
},
initComponent: function() {
var me = this;
me.rstore = Ext.create('Proxmox.data.ObjectStore', {
interval: me.interval,
model: 'pve-ha-status',
storeid: 'pve-store-' + ++Ext.idSeed,
groupField: 'type',
proxy: {
type: 'proxmox',
url: '/api2/json/cluster/ha/status/current',
},
});
me.items = [{
xtype: 'pveHAStatusView',
title: gettext('Status'),
rstore: me.rstore,
border: 0,
collapsible: true,
padding: '0 0 20 0',
}, {
xtype: 'pveHAResourcesView',
flex: 1,
collapsible: true,
title: gettext('Resources'),
border: 0,
rstore: me.rstore,
}];
me.callParent();
me.on('activate', me.rstore.startUpdate);
},
});
Ext.define('PVE.ha.StatusView', {
extend: 'Ext.grid.GridPanel',
alias: ['widget.pveHAStatusView'],
onlineHelp: 'chapter_ha_manager',
sortPriority: {
quorum: 1,
master: 2,
lrm: 3,
service: 4,
},
initComponent: function() {
var me = this;
if (!me.rstore) {
throw "no rstore given";
}
Proxmox.Utils.monStoreErrors(me, me.rstore);
var store = Ext.create('Proxmox.data.DiffStore', {
rstore: me.rstore,
sortAfterUpdate: true,
sorters: [{
sorterFn: function(rec1, rec2) {
var p1 = me.sortPriority[rec1.data.type];
var p2 = me.sortPriority[rec2.data.type];
return p1 !== p2 ? p1 > p2 ? 1 : -1 : 0;
},
}],
filters: {
property: 'type',
value: 'service',
operator: '!=',
},
});
Ext.apply(me, {
store: store,
stateful: false,
viewConfig: {
trackOver: false,
},
columns: [
{
header: gettext('Type'),
width: 80,
dataIndex: 'type',
},
{
header: gettext('Status'),
width: 80,
flex: 1,
dataIndex: 'status',
},
],
});
me.callParent();
me.on('activate', me.rstore.startUpdate);
me.on('destroy', me.rstore.stopUpdate);
},
}, function() {
Ext.define('pve-ha-status', {
extend: 'Ext.data.Model',
fields: [
'id', 'type', 'node', 'status', 'sid',
'state', 'group', 'comment',
'max_restart', 'max_relocate', 'type',
'crm_state', 'request_state',
{
name: 'vname',
convert: function(value, record) {
let sid = record.data.sid;
if (!sid) return '';
let res = sid.match(/^(\S+):(\S+)$/);
if (res[1] !== 'vm' && res[1] !== 'ct') {
return '-';
}
let vmid = res[2];
return PVE.data.ResourceStore.guestName(vmid);
},
},
],
idProperty: 'id',
});
});
Ext.define('PVE.dc.ACLAdd', {
extend: 'Proxmox.window.Edit',
alias: ['widget.pveACLAdd'],
url: '/access/acl',
method: 'PUT',
isAdd: true,
isCreate: true,
width: 400,
initComponent: function() {
let me = this;
let items = [
{
xtype: me.path ? 'hiddenfield' : 'pvePermPathSelector',
name: 'path',
value: me.path,
allowBlank: false,
fieldLabel: gettext('Path'),
},
];
if (me.aclType === 'group') {
me.subject = gettext("Group Permission");
items.push({
xtype: 'pveGroupSelector',
name: 'groups',
fieldLabel: gettext('Group'),
});
} else if (me.aclType === 'user') {
me.subject = gettext("User Permission");
items.push({
xtype: 'pmxUserSelector',
name: 'users',
fieldLabel: gettext('User'),
});
} else if (me.aclType === 'token') {
me.subject = gettext("API Token Permission");
items.push({
xtype: 'pveTokenSelector',
name: 'tokens',
fieldLabel: gettext('API Token'),
});
} else {
throw "unknown ACL type";
}
items.push({
xtype: 'pmxRoleSelector',
name: 'roles',
value: 'NoAccess',
fieldLabel: gettext('Role'),
});
if (!me.path) {
items.push({
xtype: 'proxmoxcheckbox',
name: 'propagate',
checked: true,
uncheckedValue: 0,
fieldLabel: gettext('Propagate'),
});
}
let ipanel = Ext.create('Proxmox.panel.InputPanel', {
items: items,
onlineHelp: 'pveum_permission_management',
});
Ext.apply(me, {
items: [ipanel],
});
me.callParent();
},
});
Ext.define('PVE.dc.ACLView', {
extend: 'Ext.grid.GridPanel',
alias: ['widget.pveACLView'],
onlineHelp: 'chapter_user_management',
stateful: true,
stateId: 'grid-acls',
// use fixed path
path: undefined,
initComponent: function() {
let me = this;
let store = Ext.create('Ext.data.Store', {
model: 'pve-acl',
proxy: {
type: 'proxmox',
url: "/api2/json/access/acl",
},
sorters: {
property: 'path',
direction: 'ASC',
},
});
if (me.path) {
store.addFilter(Ext.create('Ext.util.Filter', {
filterFn: item => item.data.path === me.path,
}));
}
let render_ugid = function(ugid, metaData, record) {
if (record.data.type === 'group') {
return '@' + ugid;
}
return Ext.String.htmlEncode(ugid);
};
let columns = [
{
header: gettext('User') + '/' + gettext('Group') + '/' + gettext('API Token'),
flex: 1,
sortable: true,
renderer: render_ugid,
dataIndex: 'ugid',
},
{
header: gettext('Role'),
flex: 1,
sortable: true,
dataIndex: 'roleid',
},
];
if (!me.path) {
columns.unshift({
header: gettext('Path'),
flex: 1,
sortable: true,
dataIndex: 'path',
});
columns.push({
header: gettext('Propagate'),
width: 80,
sortable: true,
dataIndex: 'propagate',
});
}
let sm = Ext.create('Ext.selection.RowModel', {});
let remove_btn = new Proxmox.button.Button({
text: gettext('Remove'),
disabled: true,
selModel: sm,
confirmMsg: gettext('Are you sure you want to remove this entry'),
handler: function(btn, event, rec) {
var params = {
'delete': 1,
path: rec.data.path,
roles: rec.data.roleid,
};
if (rec.data.type === 'group') {
params.groups = rec.data.ugid;
} else if (rec.data.type === 'user') {
params.users = rec.data.ugid;
} else if (rec.data.type === 'token') {
params.tokens = rec.data.ugid;
} else {
throw 'unknown data type';
}
Proxmox.Utils.API2Request({
url: '/access/acl',
params: params,
method: 'PUT',
waitMsgTarget: me,
callback: () => store.load(),
failure: response => Ext.Msg.alert(gettext('Error'), response.htmlStatus),
});
},
});
Proxmox.Utils.monStoreErrors(me, store);
Ext.apply(me, {
store: store,
selModel: sm,
tbar: [
{
text: gettext('Add'),
menu: {
xtype: 'menu',
items: [
{
text: gettext('Group Permission'),
iconCls: 'fa fa-fw fa-group',
handler: function() {
var win = Ext.create('PVE.dc.ACLAdd', {
aclType: 'group',
path: me.path,
});
win.on('destroy', () => store.load());
win.show();
},
},
{
text: gettext('User Permission'),
iconCls: 'fa fa-fw fa-user',
handler: function() {
var win = Ext.create('PVE.dc.ACLAdd', {
aclType: 'user',
path: me.path,
});
win.on('destroy', () => store.load());
win.show();
},
},
{
text: gettext('API Token Permission'),
iconCls: 'fa fa-fw fa-user-o',
handler: function() {
let win = Ext.create('PVE.dc.ACLAdd', {
aclType: 'token',
path: me.path,
});
win.on('destroy', () => store.load());
win.show();
},
},
],
},
},
remove_btn,
],
viewConfig: {
trackOver: false,
},
columns: columns,
listeners: {
activate: () => store.load(),
},
});
me.callParent();
},
}, function() {
Ext.define('pve-acl', {
extend: 'Ext.data.Model',
fields: [
'path', 'type', 'ugid', 'roleid',
{
name: 'propagate',
type: 'boolean',
},
],
});
});
Ext.define('pve-acme-accounts', {
extend: 'Ext.data.Model',
fields: ['name'],
proxy: {
type: 'proxmox',
url: "/api2/json/cluster/acme/account",
},
idProperty: 'name',
});
Ext.define('pve-acme-plugins', {
extend: 'Ext.data.Model',
fields: ['type', 'plugin', 'api'],
proxy: {
type: 'proxmox',
url: "/api2/json/cluster/acme/plugins",
},
idProperty: 'plugin',
});
Ext.define('PVE.dc.ACMEAccountView', {
extend: 'Ext.grid.Panel',
alias: 'widget.pveACMEAccountView',
title: gettext('Accounts'),
controller: {
xclass: 'Ext.app.ViewController',
addAccount: function() {
let me = this;
let view = me.getView();
let defaultExists = view.getStore().findExact('name', 'default') !== -1;
Ext.create('PVE.node.ACMEAccountCreate', {
defaultExists,
taskDone: function() {
me.reload();
},
}).show();
},
viewAccount: function() {
let me = this;
let view = me.getView();
let selection = view.getSelection();
if (selection.length < 1) return;
Ext.create('PVE.node.ACMEAccountView', {
accountname: selection[0].data.name,
}).show();
},
reload: function() {
let me = this;
let view = me.getView();
view.getStore().rstore.load();
},
showTaskAndReload: function(options, success, response) {
let me = this;
if (!success) return;
let upid = response.result.data;
Ext.create('Proxmox.window.TaskProgress', {
upid,
taskDone: function() {
me.reload();
},
}).show();
},
},
minHeight: 150,
emptyText: gettext('No Accounts configured'),
columns: [
{
dataIndex: 'name',
text: gettext('Name'),
renderer: Ext.String.htmlEncode,
flex: 1,
},
],
tbar: [
{
xtype: 'proxmoxButton',
text: gettext('Add'),
selModel: false,
handler: 'addAccount',
},
{
xtype: 'proxmoxButton',
text: gettext('View'),
handler: 'viewAccount',
disabled: true,
},
{
xtype: 'proxmoxStdRemoveButton',
baseurl: '/cluster/acme/account',
callback: 'showTaskAndReload',
},
],
listeners: {
itemdblclick: 'viewAccount',
},
store: {
type: 'diff',
autoDestroy: true,
autoDestroyRstore: true,
rstore: {
type: 'update',
storeid: 'pve-acme-accounts',
model: 'pve-acme-accounts',
autoStart: true,
},
sorters: 'name',
},
});
Ext.define('PVE.dc.ACMEPluginView', {
extend: 'Ext.grid.Panel',
alias: 'widget.pveACMEPluginView',
title: gettext('Challenge Plugins'),
controller: {
xclass: 'Ext.app.ViewController',
addPlugin: function() {
let me = this;
Ext.create('PVE.dc.ACMEPluginEditor', {
isCreate: true,
apiCallDone: function() {
me.reload();
},
}).show();
},
editPlugin: function() {
let me = this;
let view = me.getView();
let selection = view.getSelection();
if (selection.length < 1) return;
let plugin = selection[0].data.plugin;
Ext.create('PVE.dc.ACMEPluginEditor', {
url: `/cluster/acme/plugins/${plugin}`,
apiCallDone: function() {
me.reload();
},
}).show();
},
reload: function() {
let me = this;
let view = me.getView();
view.getStore().rstore.load();
},
},
minHeight: 150,
emptyText: gettext('No Plugins configured'),
columns: [
{
dataIndex: 'plugin',
text: gettext('Plugin'),
renderer: Ext.String.htmlEncode,
flex: 1,
},
{
dataIndex: 'api',
text: 'API',
renderer: Ext.String.htmlEncode,
flex: 1,
},
],
tbar: [
{
xtype: 'proxmoxButton',
text: gettext('Add'),
handler: 'addPlugin',
selModel: false,
},
{
xtype: 'proxmoxButton',
text: gettext('Edit'),
handler: 'editPlugin',
disabled: true,
},
{
xtype: 'proxmoxStdRemoveButton',
baseurl: '/cluster/acme/plugins',
callback: 'reload',
},
],
listeners: {
itemdblclick: 'editPlugin',
},
store: {
type: 'diff',
autoDestroy: true,
autoDestroyRstore: true,
rstore: {
type: 'update',
storeid: 'pve-acme-plugins',
model: 'pve-acme-plugins',
autoStart: true,
filters: item => !!item.data.api,
},
sorters: 'plugin',
},
});
Ext.define('PVE.dc.ACMEClusterView', {
extend: 'Ext.panel.Panel',
alias: 'widget.pveACMEClusterView',
onlineHelp: 'sysadmin_certificate_management',
items: [
{
region: 'north',
border: false,
xtype: 'pveACMEAccountView',
},
{
region: 'center',
border: false,
xtype: 'pveACMEPluginView',
},
],
});
Ext.define('PVE.dc.ACMEPluginEditor', {
extend: 'Proxmox.window.Edit',
xtype: 'pveACMEPluginEditor',
mixins: ['Proxmox.Mixin.CBind'],
onlineHelp: 'sysadmin_certs_acme_plugins',
isAdd: true,
isCreate: false,
width: 550,
url: '/cluster/acme/plugins/',
subject: 'ACME DNS Plugin',
items: [
{
xtype: 'inputpanel',
// we dynamically create fields from the given schema
// things we have to do here:
// * save which fields we created to remove them again
// * split the data from the generic 'data' field into the boxes
// * on deletion collect those values again
// * save the original values of the data field
createdFields: {},
createdInitially: false,
originalValues: {},
createSchemaFields: function(schema) {
let me = this;
// we know where to add because we define it right below
let container = me.down('container');
let datafield = me.down('field[name=data]');
let hintfield = me.down('field[name=hint]');
if (!me.createdInitially) {
[me.originalValues] = PVE.Parser.parseACMEPluginData(datafield.getValue());
}
// collect values from custom fields and add it to 'data'',
// then remove the custom fields
let data = [];
for (const [name, field] of Object.entries(me.createdFields)) {
let value = field.getValue();
if (value !== undefined && value !== null && value !== '') {
data.push(`${name}=${value}`);
}
container.remove(field);
}
let datavalue = datafield.getValue();
if (datavalue !== undefined && datavalue !== null && datavalue !== '') {
data.push(datavalue);
}
datafield.setValue(data.join('\n'));
me.createdFields = {};
if (typeof schema.fields !== 'object') {
schema.fields = {};
}
// create custom fields according to schema
let gotSchemaField = false;
let cmp = (a, b) => a[0].localeCompare(b[0]);
for (const [name, definition] of Object.entries(schema.fields).sort(cmp)) {
let xtype;
switch (definition.type) {
case 'string':
xtype = 'proxmoxtextfield';
break;
case 'integer':
xtype = 'proxmoxintegerfield';
break;
case 'number':
xtype = 'numberfield';
break;
default:
console.warn(`unknown type '${definition.type}'`);
xtype = 'proxmoxtextfield';
break;
}
let label = name;
if (typeof definition.name === "string") {
label = definition.name;
}
let field = Ext.create({
xtype,
name: `custom_${name}`,
fieldLabel: label,
width: '100%',
labelWidth: 150,
labelSeparator: '=',
emptyText: definition.default || '',
autoEl: definition.description ? {
tag: 'div',
'data-qtip': definition.description,
} : undefined,
});
me.createdFields[name] = field;
container.add(field);
gotSchemaField = true;
}
datafield.setHidden(gotSchemaField); // prefer schema-fields
if (schema.description) {
hintfield.setValue(schema.description);
hintfield.setHidden(false);
} else {
hintfield.setValue('');
hintfield.setHidden(true);
}
// parse data from field and set it to the custom ones
let extradata = [];
[data, extradata] = PVE.Parser.parseACMEPluginData(datafield.getValue());
for (const [key, value] of Object.entries(data)) {
if (me.createdFields[key]) {
me.createdFields[key].setValue(value);
me.createdFields[key].originalValue = me.originalValues[key];
} else {
extradata.push(`${key}=${value}`);
}
}
datafield.setValue(extradata.join('\n'));
if (!me.createdInitially) {
datafield.resetOriginalValue();
me.createdInitially = true; // save that we initally set that
}
},
onGetValues: function(values) {
let me = this;
let win = me.up('pveACMEPluginEditor');
if (win.isCreate) {
values.id = values.plugin;
values.type = 'dns'; // the only one for now
}
delete values.plugin;
PVE.Utils.delete_if_default(values, 'validation-delay', '30', win.isCreate);
let data = '';
for (const [name, field] of Object.entries(me.createdFields)) {
let value = field.getValue();
if (value !== null && value !== undefined && value !== '') {
data += `${name}=${value}\n`;
}
delete values[`custom_${name}`];
}
values.data = Ext.util.Base64.encode(data + values.data);
return values;
},
items: [
{
xtype: 'pmxDisplayEditField',
cbind: {
editable: (get) => get('isCreate'),
submitValue: (get) => get('isCreate'),
},
editConfig: {
flex: 1,
xtype: 'proxmoxtextfield',
allowBlank: false,
},
name: 'plugin',
labelWidth: 150,
fieldLabel: gettext('Plugin ID'),
},
{
xtype: 'proxmoxintegerfield',
name: 'validation-delay',
labelWidth: 150,
fieldLabel: gettext('Validation Delay'),
emptyText: 30,
cbind: {
deleteEmpty: '{!isCreate}',
},
minValue: 0,
maxValue: 48*60*60,
},
{
xtype: 'pveACMEApiSelector',
name: 'api',
labelWidth: 150,
listeners: {
change: function(selector) {
let schema = selector.getSchema();
selector.up('inputpanel').createSchemaFields(schema);
},
},
},
{
xtype: 'textarea',
fieldLabel: gettext('API Data'),
labelWidth: 150,
name: 'data',
},
{
xtype: 'displayfield',
fieldLabel: gettext('Hint'),
labelWidth: 150,
name: 'hint',
hidden: true,
},
],
},
],
initComponent: function() {
var me = this;
me.callParent();
if (!me.isCreate) {
me.load({
success: function(response, opts) {
me.setValues(response.result.data);
},
});
} else {
me.method = 'POST';
}
},
});
Ext.define('PVE.panel.AuthBase', {
extend: 'Proxmox.panel.InputPanel',
xtype: 'pveAuthBasePanel',
type: '',
onGetValues: function(values) {
let me = this;
if (!values.port) {
if (!me.isCreate) {
Proxmox.Utils.assemble_field_data(values, { 'delete': 'port' });
}
delete values.port;
}
if (me.isCreate) {
values.type = me.type;
}
return values;
},
initComponent: function() {
let me = this;
let options = PVE.Utils.authSchema[me.type];
if (!me.column1) { me.column1 = []; }
if (!me.column2) { me.column2 = []; }
if (!me.columnB) { me.columnB = []; }
// first field is name
me.column1.unshift({
xtype: me.isCreate ? 'textfield' : 'displayfield',
name: 'realm',
fieldLabel: gettext('Realm'),
value: me.realm,
allowBlank: false,
});
// last field is default'
me.column1.push({
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Default'),
name: 'default',
uncheckedValue: 0,
});
if (options.tfa) {
// last field of column2is tfa
me.column2.push({
xtype: 'pveTFASelector',
deleteEmpty: !me.isCreate,
});
}
me.columnB.push({
xtype: 'textfield',
name: 'comment',
fieldLabel: gettext('Comment'),
});
me.callParent();
},
});
Ext.define('PVE.dc.AuthEditBase', {
extend: 'Proxmox.window.Edit',
onlineHelp: 'pveum_authentication_realms',
isAdd: true,
fieldDefaults: {
labelWidth: 120,
},
initComponent: function() {
var me = this;
me.isCreate = !me.realm;
if (me.isCreate) {
me.url = '/api2/extjs/access/domains';
me.method = 'POST';
} else {
me.url = '/api2/extjs/access/domains/' + me.realm;
me.method = 'PUT';
}
let authConfig = PVE.Utils.authSchema[me.authType];
if (!authConfig) {
throw 'unknown auth type';
} else if (!authConfig.add && me.isCreate) {
throw 'trying to add non addable realm';
}
me.subject = authConfig.name;
let items;
let bodyPadding;
if (authConfig.syncipanel) {
bodyPadding = 0;
items = {
xtype: 'tabpanel',
region: 'center',
layout: 'fit',
bodyPadding: 10,
items: [
{
title: gettext('General'),
realm: me.realm,
xtype: authConfig.ipanel,
isCreate: me.isCreate,
type: me.authType,
},
{
title: gettext('Sync Options'),
realm: me.realm,
xtype: authConfig.syncipanel,
isCreate: me.isCreate,
type: me.authType,
},
],
};
} else {
items = [{
realm: me.realm,
xtype: authConfig.ipanel,
isCreate: me.isCreate,
type: me.authType,
}];
}
Ext.apply(me, {
items,
bodyPadding,
});
me.callParent();
if (!me.isCreate) {
me.load({
success: function(response, options) {
var data = response.result.data || {};
// just to be sure (should not happen)
if (data.type !== me.authType) {
me.close();
throw "got wrong auth type";
}
me.setValues(data);
},
});
}
},
});
Ext.define('PVE.panel.ADInputPanel', {
extend: 'PVE.panel.AuthBase',
xtype: 'pveAuthADPanel',
initComponent: function() {
let me = this;
if (me.type !== 'ad') {
throw 'invalid type';
}
me.column1 = [
{
xtype: 'textfield',
name: 'domain',
fieldLabel: gettext('Domain'),
emptyText: 'company.net',
allowBlank: false,
},
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Case-Sensitive'),
name: 'case-sensitive',
uncheckedValue: 0,
checked: true,
},
];
me.column2 = [
{
xtype: 'textfield',
fieldLabel: gettext('Server'),
name: 'server1',
allowBlank: false,
},
{
xtype: 'proxmoxtextfield',
fieldLabel: gettext('Fallback Server'),
deleteEmpty: !me.isCreate,
name: 'server2',
},
{
xtype: 'proxmoxintegerfield',
name: 'port',
fieldLabel: gettext('Port'),
minValue: 1,
maxValue: 65535,
emptyText: gettext('Default'),
submitEmptyText: false,
},
{
xtype: 'proxmoxKVComboBox',
name: 'mode',
fieldLabel: gettext('Mode'),
editable: false,
comboItems: [
['__default__', Proxmox.Utils.defaultText + ' (LDAP)'],
['ldap', 'LDAP'],
['ldap+starttls', 'STARTTLS'],
['ldaps', 'LDAPS'],
],
value: '__default__',
deleteEmpty: !me.isCreate,
listeners: {
change: function(field, newValue) {
let verifyCheckbox = field.nextSibling('proxmoxcheckbox[name=verify]');
if (newValue === 'ldap' || newValue === '__default__') {
verifyCheckbox.disable();
verifyCheckbox.setValue(0);
} else {
verifyCheckbox.enable();
}
},
},
},
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Verify Certificate'),
name: 'verify',
uncheckedValue: 0,
disabled: true,
checked: false,
autoEl: {
tag: 'div',
'data-qtip': gettext('Verify TLS certificate of the server'),
},
},
];
me.advancedItems = [
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Check connection'),
name: 'check-connection',
uncheckedValue: 0,
checked: true,
autoEl: {
tag: 'div',
'data-qtip':
gettext('Verify connection parameters and bind credentials on save'),
},
},
];
me.callParent();
},
onGetValues: function(values) {
let me = this;
if (!values.verify) {
if (!me.isCreate) {
Proxmox.Utils.assemble_field_data(values, { 'delete': 'verify' });
}
delete values.verify;
}
if (!me.isCreate) {
// Delete old `secure` parameter. It has been deprecated in favor to the
// `mode` parameter. Migration happens automatically in `onSetValues`.
Proxmox.Utils.assemble_field_data(values, { 'delete': 'secure' });
}
return me.callParent([values]);
},
onSetValues(values) {
let me = this;
if (values.secure !== undefined && !values.mode) {
// If `secure` is set, use it to determine the correct setting for `mode`
// `secure` is later deleted by `onSetValues` .
// In case *both* are set, we simply ignore `secure` and use
// whatever `mode` is set to.
values.mode = values.secure ? 'ldaps' : 'ldap';
}
return me.callParent([values]);
},
});
Ext.define('PVE.panel.LDAPInputPanel', {
extend: 'PVE.panel.AuthBase',
xtype: 'pveAuthLDAPPanel',
initComponent: function() {
let me = this;
if (me.type !== 'ldap') {
throw 'invalid type';
}
me.column1 = [
{
xtype: 'textfield',
name: 'base_dn',
fieldLabel: gettext('Base Domain Name'),
emptyText: 'CN=Users,DC=Company,DC=net',
allowBlank: false,
},
{
xtype: 'textfield',
name: 'user_attr',
emptyText: 'uid / sAMAccountName',
fieldLabel: gettext('User Attribute Name'),
allowBlank: false,
},
];
me.column2 = [
{
xtype: 'textfield',
fieldLabel: gettext('Server'),
name: 'server1',
allowBlank: false,
},
{
xtype: 'proxmoxtextfield',
fieldLabel: gettext('Fallback Server'),
deleteEmpty: !me.isCreate,
name: 'server2',
},
{
xtype: 'proxmoxintegerfield',
name: 'port',
fieldLabel: gettext('Port'),
minValue: 1,
maxValue: 65535,
emptyText: gettext('Default'),
submitEmptyText: false,
},
{
xtype: 'proxmoxKVComboBox',
name: 'mode',
fieldLabel: gettext('Mode'),
editable: false,
comboItems: [
['__default__', Proxmox.Utils.defaultText + ' (LDAP)'],
['ldap', 'LDAP'],
['ldap+starttls', 'STARTTLS'],
['ldaps', 'LDAPS'],
],
value: '__default__',
deleteEmpty: !me.isCreate,
listeners: {
change: function(field, newValue) {
let verifyCheckbox = field.nextSibling('proxmoxcheckbox[name=verify]');
if (newValue === 'ldap' || newValue === '__default__') {
verifyCheckbox.disable();
verifyCheckbox.setValue(0);
} else {
verifyCheckbox.enable();
}
},
},
},
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Verify Certificate'),
name: 'verify',
uncheckedValue: 0,
disabled: true,
checked: false,
autoEl: {
tag: 'div',
'data-qtip': gettext('Verify TLS certificate of the server'),
},
},
];
me.advancedItems = [
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Check connection'),
name: 'check-connection',
uncheckedValue: 0,
checked: true,
autoEl: {
tag: 'div',
'data-qtip':
gettext('Verify connection parameters and bind credentials on save'),
},
},
];
me.callParent();
},
onGetValues: function(values) {
let me = this;
if (!values.verify) {
if (!me.isCreate) {
Proxmox.Utils.assemble_field_data(values, { 'delete': 'verify' });
}
delete values.verify;
}
if (!me.isCreate) {
// Delete old `secure` parameter. It has been deprecated in favor to the
// `mode` parameter. Migration happens automatically in `onSetValues`.
Proxmox.Utils.assemble_field_data(values, { 'delete': 'secure' });
}
return me.callParent([values]);
},
onSetValues(values) {
let me = this;
if (values.secure !== undefined && !values.mode) {
// If `secure` is set, use it to determine the correct setting for `mode`
// `secure` is later deleted by `onSetValues` .
// In case *both* are set, we simply ignore `secure` and use
// whatever `mode` is set to.
values.mode = values.secure ? 'ldaps' : 'ldap';
}
return me.callParent([values]);
},
});
Ext.define('PVE.panel.LDAPSyncInputPanel', {
extend: 'Proxmox.panel.InputPanel',
xtype: 'pveAuthLDAPSyncPanel',
editableAttributes: ['email'],
editableDefaults: ['scope', 'enable-new'],
default_opts: {},
sync_attributes: {},
// (de)construct the sync-attributes from the list above,
// not touching all others
onGetValues: function(values) {
let me = this;
me.editableDefaults.forEach((attr) => {
if (values[attr]) {
me.default_opts[attr] = values[attr];
delete values[attr];
} else {
delete me.default_opts[attr];
}
});
let vanished_opts = [];
['acl', 'entry', 'properties'].forEach((prop) => {
if (values[`remove-vanished-${prop}`]) {
vanished_opts.push(prop);
}
delete values[`remove-vanished-${prop}`];
});
me.default_opts['remove-vanished'] = vanished_opts.join(';');
values['sync-defaults-options'] = PVE.Parser.printPropertyString(me.default_opts);
me.editableAttributes.forEach((attr) => {
if (values[attr]) {
me.sync_attributes[attr] = values[attr];
delete values[attr];
} else {
delete me.sync_attributes[attr];
}
});
values.sync_attributes = PVE.Parser.printPropertyString(me.sync_attributes);
PVE.Utils.delete_if_default(values, 'sync-defaults-options');
PVE.Utils.delete_if_default(values, 'sync_attributes');
// Force values.delete to be an array
if (typeof values.delete === 'string') {
values.delete = values.delete.split(',');
}
if (me.isCreate) {
delete values.delete; // on create we cannot delete values
}
return values;
},
setValues: function(values) {
let me = this;
if (values.sync_attributes) {
me.sync_attributes = PVE.Parser.parsePropertyString(values.sync_attributes);
delete values.sync_attributes;
me.editableAttributes.forEach((attr) => {
if (me.sync_attributes[attr]) {
values[attr] = me.sync_attributes[attr];
}
});
}
if (values['sync-defaults-options']) {
me.default_opts = PVE.Parser.parsePropertyString(values['sync-defaults-options']);
delete values.default_opts;
me.editableDefaults.forEach((attr) => {
if (me.default_opts[attr]) {
values[attr] = me.default_opts[attr];
}
});
if (me.default_opts['remove-vanished']) {
let opts = me.default_opts['remove-vanished'].split(';');
for (const opt of opts) {
values[`remove-vanished-${opt}`] = 1;
}
}
}
return me.callParent([values]);
},
column1: [
{
xtype: 'proxmoxtextfield',
name: 'bind_dn',
deleteEmpty: true,
emptyText: Proxmox.Utils.noneText,
fieldLabel: gettext('Bind User'),
},
{
xtype: 'proxmoxtextfield',
inputType: 'password',
name: 'password',
emptyText: gettext('Unchanged'),
fieldLabel: gettext('Bind Password'),
},
{
xtype: 'proxmoxtextfield',
name: 'email',
fieldLabel: gettext('E-Mail attribute'),
},
{
xtype: 'proxmoxtextfield',
name: 'group_name_attr',
deleteEmpty: true,
fieldLabel: gettext('Groupname attr.'),
},
{
xtype: 'displayfield',
value: gettext('Default Sync Options'),
},
{
xtype: 'proxmoxKVComboBox',
name: 'scope',
emptyText: Proxmox.Utils.NoneText,
fieldLabel: gettext('Scope'),
value: '__default__',
deleteEmpty: false,
comboItems: [
['__default__', Proxmox.Utils.NoneText],
['users', gettext('Users')],
['groups', gettext('Groups')],
['both', gettext('Users and Groups')],
],
},
],
column2: [
{
xtype: 'proxmoxtextfield',
name: 'user_classes',
fieldLabel: gettext('User classes'),
deleteEmpty: true,
emptyText: 'inetorgperson, posixaccount, person, user',
},
{
xtype: 'proxmoxtextfield',
name: 'group_classes',
fieldLabel: gettext('Group classes'),
deleteEmpty: true,
emptyText: 'groupOfNames, group, univentionGroup, ipausergroup',
},
{
xtype: 'proxmoxtextfield',
name: 'filter',
fieldLabel: gettext('User Filter'),
deleteEmpty: true,
},
{
xtype: 'proxmoxtextfield',
name: 'group_filter',
fieldLabel: gettext('Group Filter'),
deleteEmpty: true,
},
{
// fake for spacing
xtype: 'displayfield',
value: ' ',
},
{
xtype: 'proxmoxKVComboBox',
value: '__default__',
deleteEmpty: false,
comboItems: [
[
'__default__',
Ext.String.format(
gettext("{0} ({1})"),
Proxmox.Utils.yesText,
Proxmox.Utils.defaultText,
),
],
['1', Proxmox.Utils.yesText],
['0', Proxmox.Utils.noText],
],
name: 'enable-new',
fieldLabel: gettext('Enable new users'),
},
],
columnB: [
{
xtype: 'fieldset',
title: gettext('Remove Vanished Options'),
items: [
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('ACL'),
name: 'remove-vanished-acl',
boxLabel: gettext('Remove ACLs of vanished users and groups.'),
},
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Entry'),
name: 'remove-vanished-entry',
boxLabel: gettext('Remove vanished user and group entries.'),
},
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Properties'),
name: 'remove-vanished-properties',
boxLabel: gettext('Remove vanished properties from synced users.'),
},
],
},
],
});
Ext.define('PVE.panel.OpenIDInputPanel', {
extend: 'PVE.panel.AuthBase',
xtype: 'pveAuthOpenIDPanel',
mixins: ['Proxmox.Mixin.CBind'],
onGetValues: function(values) {
let me = this;
if (!values.verify) {
if (!me.isCreate) {
Proxmox.Utils.assemble_field_data(values, { 'delete': 'verify' });
}
delete values.verify;
}
return me.callParent([values]);
},
columnT: [
{
xtype: 'textfield',
name: 'issuer-url',
fieldLabel: gettext('Issuer URL'),
allowBlank: false,
},
],
column1: [
{
xtype: 'proxmoxtextfield',
fieldLabel: gettext('Client ID'),
name: 'client-id',
allowBlank: false,
},
{
xtype: 'proxmoxtextfield',
fieldLabel: gettext('Client Key'),
cbind: {
deleteEmpty: '{!isCreate}',
},
name: 'client-key',
},
],
column2: [
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Autocreate Users'),
name: 'autocreate',
value: 0,
cbind: {
deleteEmpty: '{!isCreate}',
},
},
{
xtype: 'pmxDisplayEditField',
name: 'username-claim',
fieldLabel: gettext('Username Claim'),
editConfig: {
xtype: 'proxmoxKVComboBox',
editable: true,
comboItems: [
['__default__', Proxmox.Utils.defaultText],
['subject', 'subject'],
['username', 'username'],
['email', 'email'],
],
},
cbind: {
value: get => get('isCreate') ? '__default__' : Proxmox.Utils.defaultText,
deleteEmpty: '{!isCreate}',
editable: '{isCreate}',
},
},
{
xtype: 'proxmoxtextfield',
name: 'scopes',
fieldLabel: gettext('Scopes'),
emptyText: `${Proxmox.Utils.defaultText} (email profile)`,
submitEmpty: false,
cbind: {
deleteEmpty: '{!isCreate}',
},
},
{
xtype: 'proxmoxKVComboBox',
name: 'prompt',
fieldLabel: gettext('Prompt'),
editable: true,
emptyText: gettext('Auth-Provider Default'),
comboItems: [
['__default__', gettext('Auth-Provider Default')],
['none', 'none'],
['login', 'login'],
['consent', 'consent'],
['select_account', 'select_account'],
],
cbind: {
deleteEmpty: '{!isCreate}',
},
},
],
advancedColumnB: [
{
xtype: 'proxmoxtextfield',
name: 'acr-values',
fieldLabel: gettext('ACR Values'),
submitEmpty: false,
cbind: {
deleteEmpty: '{!isCreate}',
},
},
],
initComponent: function() {
let me = this;
if (me.type !== 'openid') {
throw 'invalid type';
}
me.callParent();
},
});
Ext.define('PVE.dc.AuthView', {
extend: 'Ext.grid.GridPanel',
alias: ['widget.pveAuthView'],
onlineHelp: 'pveum_authentication_realms',
stateful: true,
stateId: 'grid-authrealms',
viewConfig: {
trackOver: false,
},
columns: [
{
header: gettext('Realm'),
width: 100,
sortable: true,
dataIndex: 'realm',
},
{
header: gettext('Type'),
width: 100,
sortable: true,
dataIndex: 'type',
},
{
header: gettext('TFA'),
width: 100,
sortable: true,
dataIndex: 'tfa',
},
{
header: gettext('Comment'),
sortable: false,
dataIndex: 'comment',
renderer: Ext.String.htmlEncode,
flex: 1,
},
],
store: {
model: 'pmx-domains',
sorters: {
property: 'realm',
direction: 'ASC',
},
},
openEditWindow: function(authType, realm) {
let me = this;
Ext.create('PVE.dc.AuthEditBase', {
authType,
realm,
listeners: {
destroy: () => me.reload(),
},
}).show();
},
reload: function() {
let me = this;
me.getStore().load();
},
run_editor: function() {
let me = this;
let rec = me.getSelection()[0];
if (!rec) {
return;
}
me.openEditWindow(rec.data.type, rec.data.realm);
},
open_sync_window: function() {
let me = this;
let rec = me.getSelection()[0];
if (!rec) {
return;
}
Ext.create('PVE.dc.SyncWindow', {
realm: rec.data.realm,
listeners: {
destroy: () => me.reload(),
},
}).show();
},
initComponent: function() {
var me = this;
let items = [];
for (const [authType, config] of Object.entries(PVE.Utils.authSchema)) {
if (!config.add) { continue; }
items.push({
text: config.name,
iconCls: 'fa fa-fw ' + (config.iconCls || 'fa-address-book-o'),
handler: () => me.openEditWindow(authType),
});
}
Ext.apply(me, {
tbar: [
{
text: gettext('Add'),
menu: {
items: items,
},
},
{
xtype: 'proxmoxButton',
text: gettext('Edit'),
disabled: true,
handler: () => me.run_editor(),
},
{
xtype: 'proxmoxStdRemoveButton',
baseurl: '/access/domains/',
enableFn: (rec) => PVE.Utils.authSchema[rec.data.type].add,
callback: () => me.reload(),
},
'-',
{
xtype: 'proxmoxButton',
text: gettext('Sync'),
disabled: true,
enableFn: (rec) => Boolean(PVE.Utils.authSchema[rec.data.type].syncipanel),
handler: () => me.open_sync_window(),
},
],
listeners: {
itemdblclick: () => me.run_editor(),
},
});
me.callParent();
me.reload();
},
});
Ext.define('PVE.dc.BackupDiskTree', {
extend: 'Ext.tree.Panel',
alias: 'widget.pveBackupDiskTree',
folderSort: true,
rootVisible: false,
store: {
sorters: 'id',
data: {},
},
tools: [
{
type: 'expand',
tooltip: gettext('Expand All'),
callback: panel => panel.expandAll(),
},
{
type: 'collapse',
tooltip: gettext('Collapse All'),
callback: panel => panel.collapseAll(),
},
],
columns: [
{
xtype: 'treecolumn',
text: gettext('Guest Image'),
renderer: function(value, meta, record) {
if (record.data.type) {
// guest level
let ret = value;
if (record.data.name) {
ret += " (" + record.data.name + ")";
}
return ret;
} else {
// extJS needs unique IDs but we only want to show the volumes key from "vmid:key"
return value.split(':')[1] + " - " + record.data.name;
}
},
dataIndex: 'id',
flex: 6,
},
{
text: gettext('Type'),
dataIndex: 'type',
flex: 1,
},
{
text: gettext('Backup Job'),
renderer: PVE.Utils.render_backup_status,
dataIndex: 'included',
flex: 3,
},
],
reload: function() {
let me = this;
let sm = me.getSelectionModel();
Proxmox.Utils.API2Request({
url: `/cluster/backup/${me.jobid}/included_volumes`,
waitMsgTarget: me,
method: 'GET',
failure: function(response, opts) {
Proxmox.Utils.setErrorMask(me, response.htmlStatus);
},
success: function(response, opts) {
sm.deselectAll();
me.setRootNode(response.result.data);
me.expandAll();
},
});
},
initComponent: function() {
var me = this;
if (!me.jobid) {
throw "no job id specified";
}
var sm = Ext.create('Ext.selection.TreeModel', {});
Ext.apply(me, {
selModel: sm,
fields: ['id', 'type',
{
type: 'string',
name: 'iconCls',
calculate: function(data) {
var txt = 'fa x-fa-tree fa-';
if (data.leaf && !data.type) {
return txt + 'hdd-o';
} else if (data.type === 'qemu') {
return txt + 'desktop';
} else if (data.type === 'lxc') {
return txt + 'cube';
} else {
return txt + 'question-circle';
}
},
},
],
header: {
items: [{
xtype: 'textfield',
fieldLabel: gettext('Search'),
labelWidth: 50,
emptyText: 'Name, VMID, Type',
width: 200,
padding: '0 5 0 0',
enableKeyEvents: true,
listeners: {
buffer: 500,
keyup: function(field) {
let searchValue = field.getValue().toLowerCase();
me.store.clearFilter(true);
me.store.filterBy(function(record) {
let data = {};
if (record.data.depth === 0) {
return true;
} else if (record.data.depth === 1) {
data = record.data;
} else if (record.data.depth === 2) {
data = record.parentNode.data;
}
for (const property of ['name', 'id', 'type']) {
if (!data[property]) {
continue;
}
let v = data[property].toString();
if (v !== undefined) {
v = v.toLowerCase();
if (v.includes(searchValue)) {
return true;
}
}
}
return false;
});
},
},
}],
},
});
me.callParent();
me.reload();
},
});
Ext.define('PVE.dc.BackupInfo', {
extend: 'Proxmox.panel.InputPanel',
alias: 'widget.pveBackupInfo',
viewModel: {
data: {
retentionType: 'none',
},
formulas: {
hasRetention: (get) => get('retentionType') !== 'none',
retentionKeepAll: (get) => get('retentionType') === 'all',
},
},
padding: '5 0 5 10',
column1: [
{
xtype: 'displayfield',
name: 'node',
fieldLabel: gettext('Node'),
renderer: value => value || `-- ${gettext('All')} --`,
},
{
xtype: 'displayfield',
name: 'storage',
fieldLabel: gettext('Storage'),
},
{
xtype: 'displayfield',
name: 'schedule',
fieldLabel: gettext('Schedule'),
},
{
xtype: 'displayfield',
name: 'next-run',
fieldLabel: gettext('Next Run'),
renderer: PVE.Utils.render_next_event,
},
{
xtype: 'displayfield',
name: 'selMode',
fieldLabel: gettext('Selection mode'),
},
],
column2: [
{
xtype: 'displayfield',
name: 'notification-policy',
fieldLabel: gettext('Notification'),
renderer: function(value) {
let record = this.up('pveBackupInfo')?.record;
// Fall back to old value, in case this option is not migrated yet.
let policy = value || record?.mailnotification || 'always';
let when = gettext('Always');
if (policy === 'failure') {
when = gettext('On failure only');
} else if (policy === 'never') {
when = gettext('Never');
}
// Notification-target takes precedence
let target = record?.['notification-target'] ||
record?.mailto ||
gettext('No target configured');
return `${when} (${target})`;
},
},
{
xtype: 'displayfield',
name: 'compress',
fieldLabel: gettext('Compression'),
},
{
xtype: 'displayfield',
name: 'mode',
fieldLabel: gettext('Mode'),
renderer: function(value) {
const modeToDisplay = {
snapshot: gettext('Snapshot'),
stop: gettext('Stop'),
suspend: gettext('Snapshot'),
};
return modeToDisplay[value] ?? gettext('Unknown');
},
},
{
xtype: 'displayfield',
name: 'enabled',
fieldLabel: gettext('Enabled'),
renderer: v => PVE.Parser.parseBoolean(v.toString()) ? gettext('Yes') : gettext('No'),
},
{
xtype: 'displayfield',
name: 'pool',
fieldLabel: gettext('Pool to backup'),
},
],
columnB: [
{
xtype: 'displayfield',
name: 'comment',
fieldLabel: gettext('Comment'),
renderer: Ext.String.htmlEncode,
},
{
xtype: 'fieldset',
title: gettext('Retention Configuration'),
layout: 'hbox',
collapsible: true,
defaults: {
border: false,
layout: 'anchor',
flex: 1,
},
bind: {
hidden: '{!hasRetention}',
},
items: [
{
padding: '0 10 0 0',
defaults: {
labelWidth: 110,
},
items: [{
xtype: 'displayfield',
name: 'keep-all',
fieldLabel: gettext('Keep All'),
renderer: Proxmox.Utils.format_boolean,
bind: {
hidden: '{!retentionKeepAll}',
},
}].concat(
[
['keep-last', gettext('Keep Last')],
['keep-hourly', gettext('Keep Hourly')],
].map(
name => ({
xtype: 'displayfield',
name: name[0],
fieldLabel: name[1],
bind: {
hidden: '{!hasRetention || retentionKeepAll}',
},
}),
),
),
},
{
padding: '0 0 0 10',
defaults: {
labelWidth: 110,
},
items: [
['keep-daily', gettext('Keep Daily')],
['keep-weekly', gettext('Keep Weekly')],
].map(
name => ({
xtype: 'displayfield',
name: name[0],
fieldLabel: name[1],
bind: {
hidden: '{!hasRetention || retentionKeepAll}',
},
}),
),
},
{
padding: '0 0 0 10',
defaults: {
labelWidth: 110,
},
items: [
['keep-monthly', gettext('Keep Monthly')],
['keep-yearly', gettext('Keep Yearly')],
].map(
name => ({
xtype: 'displayfield',
name: name[0],
fieldLabel: name[1],
bind: {
hidden: '{!hasRetention || retentionKeepAll}',
},
}),
),
},
],
},
],
setValues: function(values) {
var me = this;
let vm = me.getViewModel();
Ext.iterate(values, function(fieldId, val) {
let field = me.query('[isFormField][name=' + fieldId + ']')[0];
if (field) {
field.setValue(val);
}
});
if (values['prune-backups'] || values.maxfiles !== undefined) {
let keepValues;
if (values['prune-backups']) {
keepValues = values['prune-backups'];
} else if (values.maxfiles > 0) {
keepValues = { 'keep-last': values.maxfiles };
} else {
keepValues = { 'keep-all': 1 };
}
vm.set('retentionType', keepValues['keep-all'] ? 'all' : 'other');
// set values of all keep-X fields
['all', 'last', 'hourly', 'daily', 'weekly', 'monthly', 'yearly'].forEach(time => {
let name = `keep-${time}`;
me.query(`[isFormField][name=${name}]`)[0]?.setValue(keepValues[name]);
});
} else {
vm.set('retentionType', 'none');
}
// selection Mode depends on the presence/absence of several keys
let selModeField = me.query('[isFormField][name=selMode]')[0];
let selMode = 'none';
if (values.vmid) {
selMode = gettext('Include selected VMs');
}
if (values.all) {
selMode = gettext('All');
}
if (values.exclude) {
selMode = gettext('Exclude selected VMs');
}
if (values.pool) {
selMode = gettext('Pool based');
}
selModeField.setValue(selMode);
if (!values.pool) {
let poolField = me.query('[isFormField][name=pool]')[0];
poolField.setVisible(0);
}
},
initComponent: function() {
var me = this;
if (!me.record) {
throw "no data provided";
}
me.callParent();
me.setValues(me.record);
},
});
Ext.define('PVE.dc.BackedGuests', {
extend: 'Ext.grid.GridPanel',
alias: 'widget.pveBackedGuests',
stateful: true,
stateId: 'grid-dc-backed-guests',
textfilter: '',
columns: [
{
header: gettext('Type'),
dataIndex: "type",
renderer: PVE.Utils.render_resource_type,
flex: 1,
sortable: true,
},
{
header: 'VMID',
dataIndex: 'vmid',
flex: 1,
sortable: true,
},
{
header: gettext('Name'),
dataIndex: 'name',
flex: 2,
sortable: true,
},
],
viewConfig: {
stripeRows: true,
trackOver: false,
},
initComponent: function() {
let me = this;
me.store.clearFilter(true);
Ext.apply(me, {
tbar: [
'->',
gettext('Search') + ':',
' ',
{
xtype: 'textfield',
width: 200,
emptyText: 'Name, VMID, Type',
enableKeyEvents: true,
listeners: {
buffer: 500,
keyup: function(field) {
let searchValue = field.getValue().toLowerCase();
me.store.clearFilter(true);
me.store.filterBy(function(record) {
let data = record.data;
for (const property of ['name', 'vmid', 'type']) {
if (data[property] === null) {
continue;
}
let v = data[property].toString();
if (v !== undefined) {
if (v.toLowerCase().includes(searchValue)) {
return true;
}
}
}
return false;
});
},
},
},
],
});
me.callParent();
},
});
Ext.define('PVE.dc.BackupEdit', {
extend: 'Proxmox.window.Edit',
alias: ['widget.pveDcBackupEdit'],
mixins: ['Proxmox.Mixin.CBind'],
defaultFocus: undefined,
subject: gettext("Backup Job"),
bodyPadding: 0,
url: '/api2/extjs/cluster/backup',
method: 'POST',
isCreate: true,
cbindData: function() {
let me = this;
if (me.jobid) {
me.isCreate = false;
me.method = 'PUT';
me.url += `/${me.jobid}`;
}
return {};
},
controller: {
xclass: 'Ext.app.ViewController',
onGetValues: function(values) {
let me = this;
let isCreate = me.getView().isCreate;
if (!values.node) {
if (!isCreate) {
Proxmox.Utils.assemble_field_data(values, { 'delete': 'node' });
}
delete values.node;
}
// Get rid of new-old parameters for notification settings.
// These should only be set for those selected few who ran
// pve-manager from pvetest.
if (!isCreate) {
Proxmox.Utils.assemble_field_data(values, { 'delete': 'notification-policy' });
Proxmox.Utils.assemble_field_data(values, { 'delete': 'notification-target' });
}
if (!values.id && isCreate) {
values.id = 'backup-' + Ext.data.identifier.Uuid.Global.generate().slice(0, 13);
}
let selMode = values.selMode;
delete values.selMode;
if (selMode === 'all') {
values.all = 1;
values.exclude = '';
delete values.vmid;
} else if (selMode === 'exclude') {
values.all = 1;
values.exclude = values.vmid;
delete values.vmid;
} else if (selMode === 'pool') {
delete values.vmid;
}
if (selMode !== 'pool') {
delete values.pool;
}
return values;
},
nodeChange: function(f, value) {
let me = this;
me.lookup('storageSelector').setNodename(value);
let vmgrid = me.lookup('vmgrid');
let store = vmgrid.getStore();
store.clearFilter();
store.filterBy(function(rec) {
return !value || rec.get('node') === value;
});
let mode = me.lookup('modeSelector').getValue();
if (mode === 'all') {
vmgrid.selModel.selectAll(true);
}
if (mode === 'pool') {
me.selectPoolMembers();
}
},
storageChange: function(f, v) {
let me = this;
let rec = f.getStore().findRecord('storage', v, 0, false, true, true);
let compressionSelector = me.lookup('compressionSelector');
if (rec?.data?.type === 'pbs') {
compressionSelector.setValue('zstd');
compressionSelector.setDisabled(true);
} else if (!compressionSelector.getEditable()) {
compressionSelector.setDisabled(false);
}
},
selectPoolMembers: function() {
let me = this;
let mode = me.lookup('modeSelector').getValue();
if (mode !== 'pool') {
return;
}
let vmgrid = me.lookup('vmgrid');
let poolid = me.lookup('poolSelector').getValue();
vmgrid.getSelectionModel().deselectAll(true);
if (!poolid) {
return;
}
vmgrid.getStore().filter([
{
id: 'poolFilter',
property: 'pool',
value: poolid,
},
]);
vmgrid.selModel.selectAll(true);
},
modeChange: function(f, value, oldValue) {
let me = this;
let vmgrid = me.lookup('vmgrid');
vmgrid.getStore().removeFilter('poolFilter');
if (oldValue === 'all' && value !== 'all') {
vmgrid.getSelectionModel().deselectAll(true);
}
if (value === 'all') {
vmgrid.getSelectionModel().selectAll(true);
}
if (value === 'pool') {
me.selectPoolMembers();
}
},
init: function(view) {
let me = this;
if (view.isCreate) {
me.lookup('modeSelector').setValue('include');
} else {
view.load({
success: function(response, _options) {
let data = response.result.data;
// Migrate 'new'-old notification-policy back to
// old-old mailnotification. Only should affect
// users who used pve-manager from pvetest.
// This was a remnant of notifications before the
// overhaul.
let policy = data['notification-policy'];
if (policy === 'always' || policy === 'failure') {
data.mailnotification = policy;
}
if (data.exclude) {
data.vmid = data.exclude;
data.selMode = 'exclude';
} else if (data.all) {
data.vmid = '';
data.selMode = 'all';
} else if (data.pool) {
data.selMode = 'pool';
data.selPool = data.pool;
} else {
data.selMode = 'include';
}
me.getViewModel().set('selMode', data.selMode);
if (data['prune-backups']) {
Object.assign(data, data['prune-backups']);
delete data['prune-backups'];
} else if (data.maxfiles !== undefined) {
if (data.maxfiles > 0) {
data['keep-last'] = data.maxfiles;
} else {
data['keep-all'] = 1;
}
delete data.maxfiles;
}
if (data['notes-template']) {
data['notes-template'] =
PVE.Utils.unEscapeNotesTemplate(data['notes-template']);
}
view.setValues(data);
},
});
}
},
},
viewModel: {
data: {
selMode: 'include',
notificationMode: '__default__',
},
formulas: {
poolMode: (get) => get('selMode') === 'pool',
disableVMSelection: (get) => get('selMode') !== 'include' && get('selMode') !== 'exclude',
showMailtoFields: (get) =>
['auto', 'legacy-sendmail', '__default__'].includes(get('notificationMode')),
},
},
items: [
{
xtype: 'tabpanel',
region: 'center',
layout: 'fit',
bodyPadding: 10,
items: [
{
xtype: 'container',
title: gettext('General'),
region: 'center',
layout: {
type: 'vbox',
align: 'stretch',
},
items: [
{
xtype: 'inputpanel',
onlineHelp: 'chapter_vzdump',
column1: [
{
xtype: 'pveNodeSelector',
name: 'node',
fieldLabel: gettext('Node'),
allowBlank: true,
editable: true,
autoSelect: false,
emptyText: '-- ' + gettext('All') + ' --',
listeners: {
change: 'nodeChange',
},
},
{
xtype: 'pveStorageSelector',
reference: 'storageSelector',
fieldLabel: gettext('Storage'),
clusterView: true,
storageContent: 'backup',
allowBlank: false,
name: 'storage',
listeners: {
change: 'storageChange',
},
},
{
xtype: 'pveCalendarEvent',
fieldLabel: gettext('Schedule'),
allowBlank: false,
name: 'schedule',
},
{
xtype: 'proxmoxKVComboBox',
reference: 'modeSelector',
comboItems: [
['include', gettext('Include selected VMs')],
['all', gettext('All')],
['exclude', gettext('Exclude selected VMs')],
['pool', gettext('Pool based')],
],
fieldLabel: gettext('Selection mode'),
name: 'selMode',
value: '',
bind: {
value: '{selMode}',
},
listeners: {
change: 'modeChange',
},
},
{
xtype: 'pvePoolSelector',
reference: 'poolSelector',
fieldLabel: gettext('Pool to backup'),
hidden: true,
allowBlank: false,
name: 'pool',
listeners: {
change: 'selectPoolMembers',
},
bind: {
hidden: '{!poolMode}',
disabled: '{!poolMode}',
},
},
],
column2: [
{
xtype: 'proxmoxKVComboBox',
comboItems: [
[
'__default__',
Ext.String.format(
gettext('{0} (Auto)'), Proxmox.Utils.defaultText,
),
],
['auto', gettext('Auto')],
['legacy-sendmail', gettext('Email (legacy)')],
['notification-system', gettext('Notification system')],
],
fieldLabel: gettext('Notification mode'),
name: 'notification-mode',
cbind: {
deleteEmpty: '{!isCreate}',
},
bind: {
value: '{notificationMode}',
},
},
{
xtype: 'pveEmailNotificationSelector',
fieldLabel: gettext('Send email'),
name: 'mailnotification',
cbind: {
value: (get) => get('isCreate') ? 'always' : '',
deleteEmpty: '{!isCreate}',
},
bind: {
disabled: '{!showMailtoFields}',
},
},
{
xtype: 'textfield',
fieldLabel: gettext('Send email to'),
name: 'mailto',
bind: {
disabled: '{!showMailtoFields}',
},
},
{
xtype: 'pveBackupCompressionSelector',
reference: 'compressionSelector',
fieldLabel: gettext('Compression'),
name: 'compress',
cbind: {
deleteEmpty: '{!isCreate}',
},
value: 'zstd',
},
{
xtype: 'pveBackupModeSelector',
fieldLabel: gettext('Mode'),
value: 'snapshot',
name: 'mode',
},
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Enable'),
name: 'enabled',
uncheckedValue: 0,
defaultValue: 1,
checked: true,
},
],
columnB: [
{
xtype: 'proxmoxtextfield',
name: 'comment',
fieldLabel: gettext('Job Comment'),
cbind: {
deleteEmpty: '{!isCreate}',
},
autoEl: {
tag: 'div',
'data-qtip': gettext('Description of the job'),
},
},
{
xtype: 'vmselector',
reference: 'vmgrid',
height: 300,
name: 'vmid',
disabled: true,
allowBlank: false,
columnSelection: ['vmid', 'node', 'status', 'name', 'type'],
bind: {
disabled: '{disableVMSelection}',
},
},
],
advancedColumn1: [
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Repeat missed'),
name: 'repeat-missed',
uncheckedValue: 0,
defaultValue: 0,
cbind: {
deleteDefaultValue: '{!isCreate}',
},
},
],
onGetValues: function(values) {
return this.up('window').getController().onGetValues(values);
},
},
],
},
{
xtype: 'pveBackupJobPrunePanel',
title: gettext('Retention'),
cbind: {
isCreate: '{isCreate}',
},
keepAllDefaultForCreate: false,
showPBSHint: false,
fallbackHintHtml: gettext('Without any keep option, the storage\'s configuration or node\'s vzdump.conf is used as fallback'),
},
{
xtype: 'inputpanel',
title: gettext('Note Template'),
region: 'center',
layout: {
type: 'vbox',
align: 'stretch',
},
onGetValues: function(values) {
if (values['notes-template']) {
values['notes-template'] =
PVE.Utils.escapeNotesTemplate(values['notes-template']);
}
return values;
},
items: [
{
xtype: 'textarea',
name: 'notes-template',
fieldLabel: gettext('Backup Notes'),
height: 100,
maxLength: 512,
cbind: {
deleteEmpty: '{!isCreate}',
value: (get) => get('isCreate') ? '{{guestname}}' : undefined,
},
},
{
xtype: 'box',
style: {
margin: '8px 0px',
'line-height': '1.5em',
},
html: gettext('The notes are added to each backup created by this job.')
+ '{{${v}}}`).join(', '),
),
},
],
},
],
},
],
});
Ext.define('PVE.dc.BackupView', {
extend: 'Ext.grid.GridPanel',
alias: ['widget.pveDcBackupView'],
onlineHelp: 'chapter_vzdump',
allText: '-- ' + gettext('All') + ' --',
initComponent: function() {
let me = this;
let store = new Ext.data.Store({
model: 'pve-cluster-backup',
proxy: {
type: 'proxmox',
url: "/api2/json/cluster/backup",
},
});
let not_backed_store = new Ext.data.Store({
sorters: 'vmid',
proxy: {
type: 'proxmox',
url: 'api2/json/cluster/backup-info/not-backed-up',
},
});
let noBackupJobInfoButton;
let reload = function() {
store.load();
not_backed_store.load({
callback: records => noBackupJobInfoButton.setVisible(records.length > 0),
});
};
let sm = Ext.create('Ext.selection.RowModel', {});
let run_editor = function() {
let rec = sm.getSelection()[0];
if (!rec) {
return;
}
let win = Ext.create('PVE.dc.BackupEdit', {
jobid: rec.data.id,
});
win.on('destroy', reload);
win.show();
};
let run_detail = function() {
let record = sm.getSelection()[0];
if (!record) {
return;
}
Ext.create('Ext.window.Window', {
modal: true,
width: 800,
height: Ext.getBody().getViewSize().height > 1000 ? 800 : 600, // factor out as common infra?
resizable: true,
layout: 'fit',
title: gettext('Backup Details'),
items: [
{
xtype: 'panel',
region: 'center',
layout: {
type: 'vbox',
align: 'stretch',
},
items: [
{
xtype: 'pveBackupInfo',
flex: 0,
layout: 'fit',
record: record.data,
},
{
xtype: 'pveBackupDiskTree',
title: gettext('Included disks'),
flex: 1,
jobid: record.data.id,
},
],
},
],
}).show();
};
let run_backup_now = function(job) {
job = Ext.clone(job);
let jobNode = job.node;
// Remove properties related to scheduling
delete job.enabled;
delete job.starttime;
delete job.dow;
delete job.id;
delete job.schedule;
delete job.type;
delete job.node;
delete job.comment;
delete job['next-run'];
delete job['repeat-missed'];
job.all = job.all === true ? 1 : 0;
['performance', 'prune-backups'].forEach(key => {
if (job[key]) {
job[key] = PVE.Parser.printPropertyString(job[key]);
}
});
let allNodes = PVE.data.ResourceStore.getNodes();
let nodes = allNodes.filter(node => node.status === 'online').map(node => node.node);
let errors = [];
if (jobNode !== undefined) {
if (!nodes.includes(jobNode)) {
Ext.Msg.alert('Error', "Node '"+ jobNode +"' from backup job isn't online!");
return;
}
nodes = [jobNode];
} else {
let unkownNodes = allNodes.filter(node => node.status !== 'online');
if (unkownNodes.length > 0) {errors.push(unkownNodes.map(node => node.node + ": " + gettext("Node is offline")));}
}
let jobTotalCount = nodes.length, jobsStarted = 0;
Ext.Msg.show({
title: gettext('Please wait...'),
closable: false,
progress: true,
progressText: '0/' + jobTotalCount,
});
let postRequest = function() {
jobsStarted++;
Ext.Msg.updateProgress(jobsStarted / jobTotalCount, jobsStarted + '/' + jobTotalCount);
if (jobsStarted === jobTotalCount) {
Ext.Msg.hide();
if (errors.length > 0) {
Ext.Msg.alert('Error', 'Some errors have been encountered:' + gettext("Virtual Machines") + ' ',
'',
'
',
' ',
gettext('Running'),
'
',
'
{running}
',
'
',
'',
'
',
' ',
gettext('Paused'),
'
',
'
{paused}
',
'
',
'',
'
',
' ',
gettext('Stopped'),
'
',
'
{stopped}
',
'
',
'',
'
',
' ',
gettext('Templates'),
'
',
'
{template}
',
'
',
],
},
{
itemId: 'lxc',
data: {
running: 0,
paused: 0,
stopped: 0,
template: 0,
},
cls: 'centered-flex-column',
tpl: [
'' + gettext("LXC Container") + ' ',
'',
'
',
' ',
gettext('Running'),
'
',
'
{running}
',
'
',
'',
'
',
' ',
gettext('Paused'),
'
',
'
{paused}
',
'
',
'',
'
',
' ',
gettext('Stopped'),
'
',
'
{stopped}
',
'
',
'',
'
',
' ',
gettext('Templates'),
'
',
'
{template}
',
'
',
],
},
{
itemId: 'error',
colspan: 2,
data: {
num: 0,
},
columnWidth: 1,
padding: '10 250 0 250',
tpl: [
'',
'',
' ',
gettext('Error'),
'
',
'{num}
',
' ',
],
},
],
updateValues: function(qemu, lxc, error) {
let me = this;
let lazyUpdate = (query, newData) => {
let el = me.getComponent(query);
let currentData = el.data;
let keys = Object.keys(newData);
if (keys.length === Object.keys(currentData).length) {
if (keys.every(k => newData[k] === currentData[k])) {
return; // all stayed the same here, return early to avoid bogus regeneration
}
}
el.update(newData);
};
lazyUpdate('qemu', qemu);
lazyUpdate('lxc', lxc);
lazyUpdate('error', { num: error });
},
});
Ext.define('PVE.dc.Health', {
extend: 'Ext.panel.Panel',
alias: 'widget.pveDcHealth',
title: gettext('Health'),
bodyPadding: 10,
height: 250,
layout: {
type: 'hbox',
align: 'stretch',
},
defaults: {
flex: 1,
xtype: 'box',
style: {
'text-align': 'center',
},
},
nodeList: [],
nodeIndex: 0,
updateStatus: function(store, records, success) {
let me = this;
if (!success) {
return;
}
let cluster = {
iconCls: PVE.Utils.get_health_icon('good', true),
text: gettext("Standalone node - no cluster defined"),
};
let nodes = {
online: 0,
offline: 0,
};
let numNodes = 1; // by default we have one node
for (const { data } of records) {
if (data.type === 'node') {
nodes[data.online === 1 ? 'online':'offline']++;
} else if (data.type === 'cluster') {
cluster.text = `${gettext("Cluster")}: ${data.name}, ${gettext("Quorate")}: `;
cluster.text += Proxmox.Utils.format_boolean(data.quorate);
if (data.quorate !== 1) {
cluster.iconCls = PVE.Utils.get_health_icon('critical', true);
}
numNodes = data.nodes;
}
}
if (numNodes !== nodes.online + nodes.offline) {
nodes.offline = numNodes - nodes.online;
}
me.getComponent('clusterstatus').updateHealth(cluster);
me.getComponent('nodestatus').update(nodes);
},
updateCeph: function(store, records, success) {
let me = this;
let cephstatus = me.getComponent('ceph');
if (!success || records.length < 1) {
if (cephstatus.isVisible()) {
return; // if ceph status is already visible don't stop to update
}
// try all nodes until we either get a successful api call, or we tried all nodes
if (++me.nodeIndex >= me.nodeList.length) {
me.cephstore.stopUpdate();
} else {
store.getProxy().setUrl(`/api2/json/nodes/${me.nodeList[me.nodeIndex].node}/ceph/status`);
}
return;
}
let state = PVE.Utils.render_ceph_health(records[0].data.health || {});
cephstatus.updateHealth(state);
cephstatus.setVisible(true);
},
listeners: {
destroy: function() {
let me = this;
me.cephstore.stopUpdate();
},
},
items: [
{
itemId: 'clusterstatus',
xtype: 'pveHealthWidget',
title: gettext('Status'),
},
{
itemId: 'nodestatus',
data: {
online: 0,
offline: 0,
},
tpl: [
'' + gettext('Nodes') + ' ',
'
',
' ',
gettext('Online'),
'
',
'
{online}
',
'
',
'
',
' ',
gettext('Offline'),
'
',
'
{offline}
',
'
${gettext('Note:')} `
+ Ext.String.format(gettext('{0} is deprecated, use {1}'), 'U2F', 'WebAuthn'),
},
{
xtype: 'displayfield',
userCls: 'pmx-hint',
value: gettext('NOTE: Changing an AppID breaks existing U2F registrations!'),
}],
});
me.add_inputpanel_row('webauthn', gettext('WebAuthn Settings'), {
renderer: v => !v ? Proxmox.Utils.NoneText : PVE.Parser.printPropertyString(v),
width: 450,
url: "/api2/extjs/cluster/options",
onlineHelp: 'pveum_configure_webauthn',
items: [{
xtype: 'textfield',
fieldLabel: gettext('Name'),
name: 'rp', // NOTE: relying party consists of name and id, this is the name
allowBlank: false,
},
{
xtype: 'textfield',
fieldLabel: gettext('Origin'),
emptyText: Ext.String.format(gettext("Domain Lockdown (e.g., {0})"), document.location.origin),
name: 'origin',
allowBlank: true,
},
{
xtype: 'textfield',
fieldLabel: 'ID',
name: 'id',
allowBlank: false,
listeners: {
dirtychange: (f, isDirty) =>
f.up('panel').down('box[id=idChangeWarning]').setHidden(!f.originalValue || !isDirty),
},
},
{
xtype: 'container',
layout: 'hbox',
items: [
{
xtype: 'box',
flex: 1,
},
{
xtype: 'button',
text: gettext('Auto-fill'),
iconCls: 'fa fa-fw fa-pencil-square-o',
handler: function(button, ev) {
let panel = this.up('panel');
let fqdn = document.location.hostname;
panel.down('field[name=rp]').setValue(fqdn);
let idField = panel.down('field[name=id]');
let currentID = idField.getValue();
if (!currentID || currentID.length === 0) {
idField.setValue(fqdn);
}
},
},
],
},
{
xtype: 'box',
height: 25,
html: `${gettext('Note:')} `
+ gettext('WebAuthn requires using a trusted certificate.'),
},
{
xtype: 'box',
id: 'idChangeWarning',
hidden: true,
padding: '5 0 0 0',
html: '${tags}
`;
},
flex: 1,
},
],
},
store: {
data: Object.entries(PVE.UIOptions.tagTreeStyles).map(v => ({
value: v[0],
display: v[1],
})),
},
deleteDefault: true,
defaultValue: '__default__',
deleteEmpty: true,
},
{
name: 'ordering',
xtype: 'proxmoxKVComboBox',
fieldLabel: gettext('Ordering'),
comboItems: Object.entries(PVE.UIOptions.tagOrderOptions),
defaultValue: '__default__',
value: '__default__',
deleteEmpty: true,
},
{
name: 'case-sensitive',
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Case-Sensitive'),
boxLabel: gettext('Applies to new edits'),
value: 0,
},
{
xtype: 'displayfield',
fieldLabel: gettext('Color Overrides'),
},
{
name: 'colors',
xtype: 'pveTagColorGrid',
deleteEmpty: true,
height: 300,
},
],
},
],
},
};
me.rows['user-tag-access'] = {
required: true,
renderer: (value) => {
if (value === undefined) {
return Ext.String.format(gettext('Mode: {0}'), 'free');
}
let mode = value?.['user-allow'] ?? 'free';
let list = value?.['user-allow-list']?.join(',') ?? '';
let modeTxt = Ext.String.format(gettext('Mode: {0}'), mode);
let overrides = PVE.UIOptions.tagOverrides;
let tags = PVE.Utils.renderTags(list, overrides);
let listTxt = tags !== '' ? `, ${gettext('Pre-defined:')} ${tags}` : '';
return `${modeTxt}${listTxt}`;
},
header: gettext('User Tag Access'),
editor: {
xtype: 'pveUserTagAccessEdit',
},
};
me.rows['registered-tags'] = {
required: true,
renderer: (value) => {
if (value === undefined) {
return gettext('No Registered Tags');
}
let overrides = PVE.UIOptions.tagOverrides;
return PVE.Utils.renderTags(value.join(','), overrides);
},
header: gettext('Registered Tags'),
editor: {
xtype: 'pveRegisteredTagEdit',
},
};
me.selModel = Ext.create('Ext.selection.RowModel', {});
Ext.apply(me, {
tbar: [{
text: gettext('Edit'),
xtype: 'proxmoxButton',
disabled: true,
handler: function() { me.run_editor(); },
selModel: me.selModel,
}],
url: "/api2/json/cluster/options",
editorConfig: {
url: "/api2/extjs/cluster/options",
},
interval: 5000,
cwidth1: 200,
listeners: {
itemdblclick: me.run_editor,
},
});
me.callParent();
// set the new value for the default console
me.mon(me.rstore, 'load', function(store, records, success) {
if (!success) {
return;
}
var rec = store.getById('console');
PVE.UIOptions.options.console = rec.data.value;
if (rec.data.value === '__default__') {
delete PVE.UIOptions.options.console;
}
PVE.UIOptions.options['tag-style'] = store.getById('tag-style')?.data?.value;
PVE.UIOptions.updateTagSettings(PVE.UIOptions.options['tag-style']);
PVE.UIOptions.fireUIConfigChanged();
});
me.on('activate', me.rstore.startUpdate);
me.on('destroy', me.rstore.stopUpdate);
me.on('deactivate', me.rstore.stopUpdate);
},
});
Ext.define('pve-permissions', {
extend: 'Ext.data.TreeModel',
fields: [
'text', 'type',
{
type: 'boolean', name: 'propagate',
},
],
});
Ext.define('PVE.dc.PermissionGridPanel', {
extend: 'Ext.tree.Panel',
alias: 'widget.pveUserPermissionGrid',
onlineHelp: 'chapter_user_management',
scrollable: true,
layout: 'fit',
rootVisible: false,
animate: false,
sortableColumns: false,
columns: [
{
xtype: 'treecolumn',
header: gettext('Path') + '/' + gettext('Permission'),
dataIndex: 'text',
flex: 6,
},
{
header: gettext('Propagate'),
dataIndex: 'propagate',
flex: 1,
renderer: function(value) {
if (Ext.isDefined(value)) {
return Proxmox.Utils.format_boolean(value);
}
return '';
},
},
],
initComponent: function() {
let me = this;
Proxmox.Utils.API2Request({
url: '/access/permissions?userid=' + me.userid,
method: 'GET',
failure: function(response, opts) {
Proxmox.Utils.setErrorMask(me, response.htmlStatus);
me.load_task.delay(me.load_delay);
},
success: function(response, opts) {
Proxmox.Utils.setErrorMask(me, false);
let result = Ext.decode(response.responseText);
let data = result.data || {};
let root = {
name: '__root',
expanded: true,
children: [],
};
let idhash = {
'/': {
children: [],
text: '/',
type: 'path',
},
};
Ext.Object.each(data, function(path, perms) {
let path_item = {
text: path,
type: 'path',
children: [],
};
Ext.Object.each(perms, function(perm, propagate) {
let perm_item = {
text: perm,
type: 'perm',
propagate: propagate === 1,
iconCls: 'fa fa-fw fa-unlock',
leaf: true,
};
path_item.children.push(perm_item);
path_item.expandable = true;
});
idhash[path] = path_item;
});
Ext.Object.each(idhash, function(path, item) {
let parent_item = idhash['/'];
if (path === '/') {
parent_item = root;
item.expanded = true;
} else {
let split_path = path.split('/');
while (split_path.pop()) {
let parent_path = split_path.join('/');
if (idhash[parent_path]) {
parent_item = idhash[parent_path];
break;
}
}
}
parent_item.children.push(item);
});
me.setRootNode(root);
},
});
me.callParent();
me.store.sorters.add(new Ext.util.Sorter({
sorterFn: function(rec1, rec2) {
let v1 = rec1.data.text,
v2 = rec2.data.text;
if (rec1.data.type !== rec2.data.type) {
v2 = rec1.data.type;
v1 = rec2.data.type;
}
if (v1 > v2) {
return 1;
} else if (v1 < v2) {
return -1;
}
return 0;
},
}));
},
});
Ext.define('PVE.dc.PermissionView', {
extend: 'Ext.window.Window',
alias: 'widget.userShowPermissionWindow',
mixins: ['Proxmox.Mixin.CBind'],
scrollable: true,
width: 800,
height: 600,
layout: 'fit',
cbind: {
title: (get) => Ext.String.htmlEncode(get('userid')) +
` - ${gettext('Granted Permissions')}`,
},
items: [{
xtype: 'pveUserPermissionGrid',
cbind: {
userid: '{userid}',
},
}],
});
Ext.define('PVE.dc.PoolEdit', {
extend: 'Proxmox.window.Edit',
alias: ['widget.pveDcPoolEdit'],
mixins: ['Proxmox.Mixin.CBind'],
subject: gettext('Pool'),
cbindData: {
poolid: '',
isCreate: (cfg) => !cfg.poolid,
},
cbind: {
url: get => `/api2/extjs/pools/${!get('isCreate') ? '?poolid=' + get('poolid') : ''}`,
method: get => get('isCreate') ? 'POST' : 'PUT',
},
items: [
{
xtype: 'pmxDisplayEditField',
fieldLabel: gettext('Name'),
cbind: {
editable: '{isCreate}',
value: '{poolid}',
},
name: 'poolid',
allowBlank: false,
},
{
xtype: 'textfield',
fieldLabel: gettext('Comment'),
name: 'comment',
allowBlank: true,
},
],
initComponent: function() {
let me = this;
me.callParent();
if (me.poolid) {
me.load({
success: function(response) {
let data = response.result.data;
if (Ext.isArray(data)) {
me.setValues(data[0]);
} else {
me.setValues(data);
}
},
});
}
},
});
Ext.define('PVE.dc.PoolView', {
extend: 'Ext.grid.GridPanel',
alias: ['widget.pvePoolView'],
onlineHelp: 'pveum_pools',
stateful: true,
stateId: 'grid-pools',
initComponent: function() {
var me = this;
var store = new Ext.data.Store({
model: 'pve-pools',
sorters: {
property: 'poolid',
direction: 'ASC',
},
});
var reload = function() {
store.load();
};
var sm = Ext.create('Ext.selection.RowModel', {});
var remove_btn = Ext.create('Proxmox.button.StdRemoveButton', {
selModel: sm,
baseurl: '/pools/',
callback: function() {
reload();
},
getUrl: function(rec) {
return '/pools/?poolid=' + rec.getId();
},
});
var run_editor = function() {
var rec = sm.getSelection()[0];
if (!rec) {
return;
}
var win = Ext.create('PVE.dc.PoolEdit', {
poolid: rec.data.poolid,
});
win.on('destroy', reload);
win.show();
};
var edit_btn = new Proxmox.button.Button({
text: gettext('Edit'),
disabled: true,
selModel: sm,
handler: run_editor,
});
var tbar = [
{
text: gettext('Create'),
handler: function() {
var win = Ext.create('PVE.dc.PoolEdit', {});
win.on('destroy', reload);
win.show();
},
},
edit_btn, remove_btn,
];
Proxmox.Utils.monStoreErrors(me, store);
Ext.apply(me, {
store: store,
selModel: sm,
tbar: tbar,
viewConfig: {
trackOver: false,
},
columns: [
{
header: gettext('Name'),
width: 200,
sortable: true,
dataIndex: 'poolid',
},
{
header: gettext('Comment'),
sortable: false,
renderer: Ext.String.htmlEncode,
dataIndex: 'comment',
flex: 1,
},
],
listeners: {
activate: reload,
itemdblclick: run_editor,
},
});
me.callParent();
},
});
Ext.define('PVE.dc.RoleEdit', {
extend: 'Proxmox.window.Edit',
xtype: 'pveDcRoleEdit',
width: 400,
initComponent: function() {
var me = this;
me.isCreate = !me.roleid;
var url;
var method;
if (me.isCreate) {
url = '/api2/extjs/access/roles';
method = 'POST';
} else {
url = '/api2/extjs/access/roles/' + me.roleid;
method = 'PUT';
}
Ext.applyIf(me, {
subject: gettext('Role'),
url: url,
method: method,
items: [
{
xtype: me.isCreate ? 'proxmoxtextfield' : 'displayfield',
name: 'roleid',
value: me.roleid,
allowBlank: false,
fieldLabel: gettext('Name'),
},
{
xtype: 'pvePrivilegesSelector',
name: 'privs',
value: me.privs,
allowBlank: false,
fieldLabel: gettext('Privileges'),
},
],
});
me.callParent();
if (!me.isCreate) {
me.load({
success: function(response) {
var data = response.result.data;
var keys = Ext.Object.getKeys(data);
me.setValues({
privs: keys,
roleid: me.roleid,
});
},
});
}
},
});
Ext.define('PVE.dc.RoleView', {
extend: 'Ext.grid.GridPanel',
alias: ['widget.pveRoleView'],
onlineHelp: 'pveum_roles',
stateful: true,
stateId: 'grid-roles',
initComponent: function() {
let me = this;
let store = new Ext.data.Store({
model: 'pmx-roles',
sorters: {
property: 'roleid',
direction: 'ASC',
},
});
Proxmox.Utils.monStoreErrors(me, store);
let sm = Ext.create('Ext.selection.RowModel', {});
let run_editor = function() {
let rec = sm.getSelection()[0];
if (!rec) {
return;
}
if (rec.data.special) {
return;
}
Ext.create('PVE.dc.RoleEdit', {
roleid: rec.data.roleid,
privs: rec.data.privs,
listeners: {
destroy: () => store.load(),
},
autoShow: true,
});
};
Ext.apply(me, {
store: store,
selModel: sm,
viewConfig: {
trackOver: false,
},
columns: [
{
header: gettext('Built-In'),
width: 65,
sortable: true,
dataIndex: 'special',
renderer: Proxmox.Utils.format_boolean,
},
{
header: gettext('Name'),
width: 150,
sortable: true,
dataIndex: 'roleid',
},
{
itemid: 'privs',
header: gettext('Privileges'),
sortable: false,
renderer: (value, metaData) => {
if (!value) {
return '-';
}
metaData.style = 'white-space:normal;'; // allow word wrap
return value.replace(/,/g, ' ');
},
variableRowHeight: true,
dataIndex: 'privs',
flex: 1,
},
],
listeners: {
activate: function() {
store.load();
},
itemdblclick: run_editor,
},
tbar: [
{
text: gettext('Create'),
handler: function() {
Ext.create('PVE.dc.RoleEdit', {
listeners: {
destroy: () => store.load(),
},
autoShow: true,
});
},
},
{
xtype: 'proxmoxButton',
text: gettext('Edit'),
disabled: true,
selModel: sm,
handler: run_editor,
enableFn: (rec) => !rec.data.special,
},
{
xtype: 'proxmoxStdRemoveButton',
selModel: sm,
callback: () => store.load(),
baseurl: '/access/roles/',
enableFn: (rec) => !rec.data.special,
},
],
});
me.callParent();
},
});
Ext.define('pve-security-groups', {
extend: 'Ext.data.Model',
fields: ['group', 'comment', 'digest'],
idProperty: 'group',
});
Ext.define('PVE.SecurityGroupEdit', {
extend: 'Proxmox.window.Edit',
base_url: "/cluster/firewall/groups",
allow_iface: false,
initComponent: function() {
var me = this;
me.isCreate = me.group_name === undefined;
var subject;
me.url = '/api2/extjs' + me.base_url;
me.method = 'POST';
var items = [
{
xtype: 'textfield',
name: 'group',
value: me.group_name || '',
fieldLabel: gettext('Name'),
allowBlank: false,
},
{
xtype: 'textfield',
name: 'comment',
value: me.group_comment || '',
fieldLabel: gettext('Comment'),
},
];
if (me.isCreate) {
subject = gettext('Security Group');
} else {
subject = gettext('Security Group') + " '" + me.group_name + "'";
items.push({
xtype: 'hiddenfield',
name: 'rename',
value: me.group_name,
});
}
var ipanel = Ext.create('Proxmox.panel.InputPanel', {
// InputPanel does not have a 'create' property, does it need a 'isCreate'
isCreate: me.isCreate,
items: items,
});
Ext.apply(me, {
subject: subject,
items: [ipanel],
});
me.callParent();
},
});
Ext.define('PVE.SecurityGroupList', {
extend: 'Ext.grid.Panel',
alias: 'widget.pveSecurityGroupList',
stateful: true,
stateId: 'grid-securitygroups',
rulePanel: undefined,
addBtn: undefined,
removeBtn: undefined,
editBtn: undefined,
base_url: "/cluster/firewall/groups",
initComponent: function() {
let me = this;
if (!me.base_url) {
throw "no base_url specified";
}
let store = new Ext.data.Store({
model: 'pve-security-groups',
proxy: {
type: 'proxmox',
url: '/api2/json' + me.base_url,
},
sorters: {
property: 'group',
direction: 'ASC',
},
});
let sm = Ext.create('Ext.selection.RowModel', {});
let caps = Ext.state.Manager.get('GuiCap');
let canEdit = !!caps.dc['Sys.Modify'];
let reload = function() {
let oldrec = sm.getSelection()[0];
store.load((records, operation, success) => {
if (oldrec) {
let rec = store.findRecord('group', oldrec.data.group, 0, false, true, true);
if (rec) {
sm.select(rec);
}
}
});
};
let run_editor = function() {
let rec = sm.getSelection()[0];
if (!rec || !canEdit) {
return;
}
Ext.create('PVE.SecurityGroupEdit', {
digest: rec.data.digest,
group_name: rec.data.group,
group_comment: rec.data.comment,
listeners: {
destroy: () => reload(),
},
autoShow: true,
});
};
me.editBtn = new Proxmox.button.Button({
text: gettext('Edit'),
enableFn: rec => canEdit,
disabled: true,
selModel: sm,
handler: run_editor,
});
me.addBtn = new Proxmox.button.Button({
text: gettext('Create'),
disabled: !canEdit,
handler: function() {
sm.deselectAll();
var win = Ext.create('PVE.SecurityGroupEdit', {});
win.show();
win.on('destroy', reload);
},
});
me.removeBtn = Ext.create('Proxmox.button.StdRemoveButton', {
selModel: sm,
baseurl: me.base_url + '/',
enableFn: (rec) => canEdit && rec && me.base_url,
callback: () => reload(),
});
Ext.apply(me, {
store: store,
tbar: ['' + gettext('Group') + ': ', me.addBtn, me.removeBtn, me.editBtn],
selModel: sm,
columns: [
{
header: gettext('Group'),
dataIndex: 'group',
width: '100',
},
{
header: gettext('Comment'),
dataIndex: 'comment',
renderer: Ext.String.htmlEncode,
flex: 1,
},
],
listeners: {
itemdblclick: run_editor,
select: function(_sm, rec) {
if (!me.rulePanel) {
me.rulePanel = me.up('panel').down('pveFirewallRules');
}
me.rulePanel.setBaseUrl(`/cluster/firewall/groups/${rec.data.group}`);
},
deselect: function() {
if (!me.rulePanel) {
me.rulePanel = me.up('panel').down('pveFirewallRules');
}
me.rulePanel.setBaseUrl(undefined);
},
show: reload,
},
});
me.callParent();
store.load();
},
});
Ext.define('PVE.SecurityGroups', {
extend: 'Ext.panel.Panel',
alias: 'widget.pveSecurityGroups',
title: 'Security Groups',
onlineHelp: 'pve_firewall_security_groups',
layout: 'border',
items: [
{
xtype: 'pveFirewallRules',
region: 'center',
allow_groups: false,
list_refs_url: '/cluster/firewall/refs',
tbar_prefix: '' + gettext('Rules') + ': ',
border: false,
},
{
xtype: 'pveSecurityGroupList',
region: 'west',
width: '25%',
border: false,
split: true,
},
],
listeners: {
show: function() {
let sglist = this.down('pveSecurityGroupList');
sglist.fireEvent('show', sglist);
},
},
});
Ext.define('PVE.dc.StorageView', {
extend: 'Ext.grid.GridPanel',
alias: ['widget.pveStorageView'],
onlineHelp: 'chapter_storage',
stateful: true,
stateId: 'grid-dc-storage',
createStorageEditWindow: function(type, sid) {
let schema = PVE.Utils.storageSchema[type];
if (!schema || !schema.ipanel) {
throw "no editor registered for storage type: " + type;
}
Ext.create('PVE.storage.BaseEdit', {
paneltype: 'PVE.storage.' + schema.ipanel,
type: type,
storageId: sid,
canDoBackups: schema.backups,
autoShow: true,
listeners: {
destroy: this.reloadStore,
},
});
},
initComponent: function() {
let me = this;
let store = new Ext.data.Store({
model: 'pve-storage',
proxy: {
type: 'proxmox',
url: "/api2/json/storage",
},
sorters: {
property: 'storage',
direction: 'ASC',
},
});
let sm = Ext.create('Ext.selection.RowModel', {});
let run_editor = function() {
let rec = sm.getSelection()[0];
if (!rec) {
return;
}
let { type, storage } = rec.data;
me.createStorageEditWindow(type, storage);
};
let edit_btn = new Proxmox.button.Button({
text: gettext('Edit'),
disabled: true,
selModel: sm,
handler: run_editor,
});
let remove_btn = Ext.create('Proxmox.button.StdRemoveButton', {
selModel: sm,
baseurl: '/storage/',
callback: () => store.load(),
});
// else we cannot dynamically generate the add menu handlers
let addHandleGenerator = function(type) {
return function() { me.createStorageEditWindow(type); };
};
let addMenuItems = [];
for (const [type, storage] of Object.entries(PVE.Utils.storageSchema)) {
if (storage.hideAdd) {
continue;
}
addMenuItems.push({
text: PVE.Utils.format_storage_type(type),
iconCls: 'fa fa-fw fa-' + storage.faIcon,
handler: addHandleGenerator(type),
});
}
Ext.apply(me, {
store: store,
reloadStore: () => store.load(),
selModel: sm,
viewConfig: {
trackOver: false,
},
tbar: [
{
text: gettext('Add'),
menu: new Ext.menu.Menu({
items: addMenuItems,
}),
},
remove_btn,
edit_btn,
],
columns: [
{
header: 'ID',
flex: 2,
sortable: true,
dataIndex: 'storage',
},
{
header: gettext('Type'),
flex: 1,
sortable: true,
dataIndex: 'type',
renderer: PVE.Utils.format_storage_type,
},
{
header: gettext('Content'),
flex: 3,
sortable: true,
dataIndex: 'content',
renderer: PVE.Utils.format_content_types,
},
{
header: gettext('Path') + '/' + gettext('Target'),
flex: 2,
sortable: true,
dataIndex: 'path',
renderer: function(value, metaData, record) {
if (record.data.target) {
return record.data.target;
}
return value;
},
},
{
header: gettext('Shared'),
flex: 1,
sortable: true,
dataIndex: 'shared',
renderer: Proxmox.Utils.format_boolean,
},
{
header: gettext('Enabled'),
flex: 1,
sortable: true,
dataIndex: 'disable',
renderer: Proxmox.Utils.format_neg_boolean,
},
{
header: gettext('Bandwidth Limit'),
flex: 2,
sortable: true,
dataIndex: 'bwlimit',
},
],
listeners: {
activate: () => store.load(),
itemdblclick: run_editor,
},
});
me.callParent();
},
}, function() {
Ext.define('pve-storage', {
extend: 'Ext.data.Model',
fields: [
'path', 'type', 'content', 'server', 'portal', 'target', 'export', 'storage',
{ name: 'shared', type: 'boolean' },
{ name: 'disable', type: 'boolean' },
],
idProperty: 'storage',
});
});
Ext.define('PVE.dc.Summary', {
extend: 'Ext.panel.Panel',
alias: 'widget.pveDcSummary',
scrollable: true,
bodyPadding: 5,
layout: 'column',
defaults: {
padding: 5,
columnWidth: 1,
},
items: [
{
itemId: 'dcHealth',
xtype: 'pveDcHealth',
},
{
itemId: 'dcGuests',
xtype: 'pveDcGuests',
},
{
title: gettext('Resources'),
xtype: 'panel',
minHeight: 250,
bodyPadding: 5,
layout: 'hbox',
defaults: {
xtype: 'proxmoxGauge',
flex: 1,
},
items: [
{
title: gettext('CPU'),
itemId: 'cpu',
},
{
title: gettext('Memory'),
itemId: 'memory',
},
{
title: gettext('Storage'),
itemId: 'storage',
},
],
},
{
itemId: 'nodeview',
xtype: 'pveDcNodeView',
height: 250,
},
{
title: gettext('Subscriptions'),
height: 220,
items: [
{
xtype: 'pveHealthWidget',
itemId: 'subscriptions',
userCls: 'pointer',
listeners: {
element: 'el',
click: function() {
if (this.component.userCls === 'pointer') {
window.open('https://www.proxmox.com/en/proxmox-virtual-environment/pricing', '_blank');
}
},
},
},
],
},
],
listeners: {
resize: function(panel) {
Proxmox.Utils.updateColumns(panel);
},
},
initComponent: function() {
var me = this;
var rstore = Ext.create('Proxmox.data.UpdateStore', {
interval: 3000,
storeid: 'pve-cluster-status',
model: 'pve-dc-nodes',
proxy: {
type: 'proxmox',
url: "/api2/json/cluster/status",
},
});
var gridstore = Ext.create('Proxmox.data.DiffStore', {
rstore: rstore,
filters: {
property: 'type',
value: 'node',
},
sorters: {
property: 'id',
direction: 'ASC',
},
});
me.callParent();
me.getComponent('nodeview').setStore(gridstore);
var gueststatus = me.getComponent('dcGuests');
var cpustat = me.down('#cpu');
var memorystat = me.down('#memory');
var storagestat = me.down('#storage');
var sp = Ext.state.Manager.getProvider();
me.mon(PVE.data.ResourceStore, 'load', function(curstore, results) {
me.suspendLayout = true;
let cpu = 0, maxcpu = 0;
let memory = 0, maxmem = 0;
let used = 0, total = 0;
let countedStorage = {}, usableStorages = {};
let storages = sp.get('dash-storages') || '';
storages.split(',').filter(v => v !== '').forEach(storage => {
usableStorages[storage] = true;
});
let qemu = {
running: 0,
paused: 0,
stopped: 0,
template: 0,
};
let lxc = {
running: 0,
paused: 0,
stopped: 0,
template: 0,
};
let error = 0;
for (const { data } of results) {
switch (data.type) {
case 'node':
cpu += data.cpu * data.maxcpu;
maxcpu += data.maxcpu || 0;
memory += data.mem || 0;
maxmem += data.maxmem || 0;
if (gridstore.getById(data.id)) {
let griditem = gridstore.getById(data.id);
griditem.set('cpuusage', data.cpu);
let max = data.maxmem || 1;
let val = data.mem || 0;
griditem.set('memoryusage', val / max);
griditem.set('uptime', data.uptime);
griditem.commit(); // else the store marks the field as dirty
}
break;
case 'storage': {
let sid = !data.shared || data.storage === 'local' ? data.id : data.storage;
if (!Ext.Object.isEmpty(usableStorages)) {
if (usableStorages[data.id] !== true) {
break;
}
sid = data.id;
} else if (countedStorage[sid]) {
break;
}
used += data.disk;
total += data.maxdisk;
countedStorage[sid] = true;
break;
}
case 'qemu':
qemu[data.template ? 'template' : data.status]++;
if (data.hastate === 'error') {
error++;
}
break;
case 'lxc':
lxc[data.template ? 'template' : data.status]++;
if (data.hastate === 'error') {
error++;
}
break;
default: break;
}
}
let text = Ext.String.format(gettext('of {0} CPU(s)'), maxcpu);
cpustat.updateValue(cpu/maxcpu, text);
text = Ext.String.format(gettext('{0} of {1}'), Proxmox.Utils.render_size(memory), Proxmox.Utils.render_size(maxmem));
memorystat.updateValue(memory/maxmem, text);
text = Ext.String.format(gettext('{0} of {1}'), Proxmox.Utils.render_size(used), Proxmox.Utils.render_size(total));
storagestat.updateValue(used/total, text);
gueststatus.updateValues(qemu, lxc, error);
me.suspendLayout = false;
me.updateLayout(true);
});
let dcHealth = me.getComponent('dcHealth');
me.mon(rstore, 'load', dcHealth.updateStatus, dcHealth);
let subs = me.down('#subscriptions');
me.mon(rstore, 'load', function(store, records, success) {
var level;
var mixed = false;
for (let i = 0; i < records.length; i++) {
let node = records[i];
if (node.get('type') !== 'node' || node.get('status') === 'offline') {
continue;
}
let curlevel = node.get('level');
if (curlevel === '') { // no subscription beats all, set it and break the loop
level = '';
break;
}
if (level === undefined) { // save level
level = curlevel;
} else if (level !== curlevel) { // detect different levels
mixed = true;
}
}
let data = {
title: Proxmox.Utils.unknownText,
text: Proxmox.Utils.unknownText,
iconCls: PVE.Utils.get_health_icon(undefined, true),
};
if (level === '') {
data = {
title: gettext('No Subscription'),
iconCls: PVE.Utils.get_health_icon('critical', true),
text: gettext('You have at least one node without subscription.'),
};
subs.setUserCls('pointer');
} else if (mixed) {
data = {
title: gettext('Mixed Subscriptions'),
iconCls: PVE.Utils.get_health_icon('warning', true),
text: gettext('Warning: Your subscription levels are not the same.'),
};
subs.setUserCls('pointer');
} else if (level) {
data = {
title: PVE.Utils.render_support_level(level),
iconCls: PVE.Utils.get_health_icon('good', true),
text: gettext('Your subscription status is valid.'),
};
subs.setUserCls('');
}
subs.setData(data);
});
me.on('destroy', function() {
rstore.stopUpdate();
});
me.mon(sp, 'statechange', function(provider, key, value) {
if (key !== 'summarycolumns') {
return;
}
Proxmox.Utils.updateColumns(me);
});
rstore.startUpdate();
},
});
Ext.define('PVE.dc.Support', {
extend: 'Ext.panel.Panel',
alias: 'widget.pveDcSupport',
pveGuidePath: '/pve-docs/index.html',
onlineHelp: 'getting_help',
invalidHtml: 'No valid subscription ' + PVE.Utils.noSubKeyHtml,
communityHtml: 'Please use the public community forum for any questions.',
activeHtml: 'Please use our support portal for any questions. You can also use the public community forum to get additional information.',
bugzillaHtml: 'Bug Tracking Our bug tracking system is available here .',
docuHtml: function() {
var me = this;
var guideUrl = window.location.origin + me.pveGuidePath;
var text = Ext.String.format('Documentation '
+ 'The official Proxmox VE Administration Guide'
+ ' is included with this installation and can be browsed at '
+ '{0} ', guideUrl);
return text;
},
updateActive: function(data) {
var me = this;
var html = '' + data.productname + ' ' + me.activeHtml;
html += '' + data.productname + ' ' + me.communityHtml;
html += '${realm} `;
},
hidden: !!me.fixedUser,
flex: 2,
},
{
header: gettext('Token Name'),
dataIndex: 'tokenid',
hideable: false,
flex: 1,
},
{
header: gettext('Expire'),
dataIndex: 'expire',
hideable: false,
renderer: Proxmox.Utils.format_expire,
flex: 1,
},
{
header: gettext('Comment'),
dataIndex: 'comment',
renderer: Ext.String.htmlEncode,
flex: 3,
},
{
header: gettext('Privilege Separation'),
dataIndex: 'privsep',
hideable: false,
renderer: Proxmox.Utils.format_boolean,
flex: 1,
},
],
listeners: {
activate: reload,
itemdblclick: (view, rec) => run_editor(rec),
},
});
if (me.fixedUser) {
reload();
}
me.callParent();
},
});
Ext.define('PVE.window.TokenView', {
extend: 'Ext.window.Window',
mixins: ['Proxmox.Mixin.CBind'],
modal: true,
subject: gettext('API Tokens'),
scrollable: true,
layout: 'fit',
width: 800,
height: 400,
cbind: {
title: gettext('API Tokens') + ' - {userid}',
},
items: [{
xtype: 'pveTokenView',
cbind: {
fixedUser: '{userid}',
},
}],
});
Ext.define('PVE.dc.UserEdit', {
extend: 'Proxmox.window.Edit',
alias: ['widget.pveDcUserEdit'],
isAdd: true,
initComponent: function() {
let me = this;
me.isCreate = !me.userid;
let url = '/api2/extjs/access/users';
let method = 'POST';
if (!me.isCreate) {
url += '/' + encodeURIComponent(me.userid);
method = 'PUT';
}
let verifypw, pwfield;
let validate_pw = function() {
if (verifypw.getValue() !== pwfield.getValue()) {
return gettext("Passwords do not match");
}
return true;
};
verifypw = Ext.createWidget('textfield', {
inputType: 'password',
fieldLabel: gettext('Confirm password'),
name: 'verifypassword',
submitValue: false,
disabled: true,
hidden: true,
validator: validate_pw,
});
pwfield = Ext.createWidget('textfield', {
inputType: 'password',
fieldLabel: gettext('Password'),
minLength: 5,
name: 'password',
disabled: true,
hidden: true,
validator: validate_pw,
});
let column1 = [
{
xtype: me.isCreate ? 'textfield' : 'displayfield',
name: 'userid',
fieldLabel: gettext('User name'),
value: me.userid,
renderer: Ext.String.htmlEncode,
allowBlank: false,
submitValue: !!me.isCreate,
},
pwfield,
verifypw,
{
xtype: 'pveGroupSelector',
name: 'groups',
multiSelect: true,
allowBlank: true,
fieldLabel: gettext('Group'),
},
{
xtype: 'pmxExpireDate',
name: 'expire',
},
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Enabled'),
name: 'enable',
uncheckedValue: 0,
defaultValue: 1,
checked: true,
},
];
let column2 = [
{
xtype: 'textfield',
name: 'firstname',
fieldLabel: gettext('First Name'),
},
{
xtype: 'textfield',
name: 'lastname',
fieldLabel: gettext('Last Name'),
},
{
xtype: 'textfield',
name: 'email',
fieldLabel: gettext('E-Mail'),
vtype: 'proxmoxMail',
},
];
if (me.isCreate) {
column1.splice(1, 0, {
xtype: 'pmxRealmComboBox',
name: 'realm',
fieldLabel: gettext('Realm'),
allowBlank: false,
matchFieldWidth: false,
listConfig: { width: 300 },
listeners: {
change: function(combo, realm) {
me.realm = realm;
pwfield.setVisible(realm === 'pve');
pwfield.setDisabled(realm !== 'pve');
verifypw.setVisible(realm === 'pve');
verifypw.setDisabled(realm !== 'pve');
},
},
submitValue: false,
});
}
var ipanel = Ext.create('Proxmox.panel.InputPanel', {
column1: column1,
column2: column2,
columnB: [
{
xtype: 'textfield',
name: 'comment',
fieldLabel: gettext('Comment'),
},
],
advancedItems: [
{
xtype: 'textfield',
name: 'keys',
fieldLabel: gettext('Key IDs'),
},
],
onGetValues: function(values) {
if (me.realm) {
values.userid = values.userid + '@' + me.realm;
}
if (!values.password) {
delete values.password;
}
return values;
},
});
Ext.applyIf(me, {
subject: gettext('User'),
url: url,
method: method,
fieldDefaults: {
labelWidth: 110, // some translation are quite long (e.g., Spanish)
},
items: [ipanel],
});
me.callParent();
if (!me.isCreate) {
me.load({
success: function(response, options) {
var data = response.result.data;
me.setValues(data);
if (data.keys) {
if (data.keys === 'x!oath' || data.keys === 'x!u2f') {
me.down('[name="keys"]').setDisabled(1);
}
}
},
});
}
},
});
Ext.define('PVE.dc.UserView', {
extend: 'Ext.grid.GridPanel',
alias: ['widget.pveUserView'],
onlineHelp: 'pveum_users',
stateful: true,
stateId: 'grid-users',
initComponent: function() {
var me = this;
var caps = Ext.state.Manager.get('GuiCap');
var store = new Ext.data.Store({
id: "users",
model: 'pmx-users',
sorters: {
property: 'userid',
direction: 'ASC',
},
});
let reload = () => store.load();
let sm = Ext.create('Ext.selection.RowModel', {});
let remove_btn = Ext.create('Proxmox.button.StdRemoveButton', {
selModel: sm,
baseurl: '/access/users/',
dangerous: true,
enableFn: rec => caps.access['User.Modify'] && rec.data.userid !== 'root@pam',
callback: () => reload(),
});
let run_editor = function() {
var rec = sm.getSelection()[0];
if (!rec || !caps.access['User.Modify']) {
return;
}
Ext.create('PVE.dc.UserEdit', {
userid: rec.data.userid,
autoShow: true,
listeners: {
destroy: () => reload(),
},
});
};
let edit_btn = new Proxmox.button.Button({
text: gettext('Edit'),
disabled: true,
enableFn: function(rec) {
return !!caps.access['User.Modify'];
},
selModel: sm,
handler: run_editor,
});
let pwchange_btn = new Proxmox.button.Button({
text: gettext('Password'),
disabled: true,
selModel: sm,
enableFn: function(record) {
let type = record.data['realm-type'];
if (type) {
if (PVE.Utils.authSchema[type]) {
return !!PVE.Utils.authSchema[type].pwchange;
}
}
return false;
},
handler: function(btn, event, rec) {
Ext.create('Proxmox.window.PasswordEdit', {
userid: rec.data.userid,
autoShow: true,
listeners: {
destroy: () => reload(),
},
});
},
});
var perm_btn = new Proxmox.button.Button({
text: gettext('Permissions'),
disabled: true,
selModel: sm,
handler: function(btn, event, rec) {
Ext.create('PVE.dc.PermissionView', {
userid: rec.data.userid,
autoShow: true,
listeners: {
destroy: () => reload(),
},
});
},
});
let unlock_btn = new Proxmox.button.Button({
text: gettext('Unlock TFA'),
disabled: true,
selModel: sm,
enableFn: rec => !!(caps.access['User.Modify'] &&
(rec.data['totp-locked'] || rec.data['tfa-locked-until'])),
handler: function(btn, event, rec) {
Ext.Msg.confirm(
Ext.String.format(gettext('Unlock TFA authentication for {0}'), rec.data.userid),
gettext("Locked 2nd factors can happen if the user's password was leaked. Are you sure you want to unlock the user?"),
function(btn_response) {
if (btn_response === 'yes') {
Proxmox.Utils.API2Request({
url: `/access/users/${rec.data.userid}/unlock-tfa`,
waitMsgTarget: me,
method: 'PUT',
failure: function(response, options) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
},
success: function(response, options) {
reload();
},
});
}
},
);
},
});
Ext.apply(me, {
store: store,
selModel: sm,
tbar: [
{
text: gettext('Add'),
disabled: !caps.access['User.Modify'],
handler: function() {
Ext.create('PVE.dc.UserEdit', {
autoShow: true,
listeners: {
destroy: () => reload(),
},
});
},
},
'-',
edit_btn,
remove_btn,
'-',
pwchange_btn,
'-',
perm_btn,
'-',
unlock_btn,
],
viewConfig: {
trackOver: false,
},
columns: [
{
header: gettext('User name'),
width: 200,
sortable: true,
renderer: Proxmox.Utils.render_username,
dataIndex: 'userid',
},
{
header: gettext('Realm'),
width: 100,
sortable: true,
renderer: Proxmox.Utils.render_realm,
dataIndex: 'userid',
},
{
header: gettext('Enabled'),
width: 80,
sortable: true,
renderer: Proxmox.Utils.format_boolean,
dataIndex: 'enable',
},
{
header: gettext('Expire'),
width: 80,
sortable: true,
renderer: Proxmox.Utils.format_expire,
dataIndex: 'expire',
},
{
header: gettext('Name'),
width: 150,
sortable: true,
renderer: PVE.Utils.render_full_name,
dataIndex: 'firstname',
},
{
header: 'TFA',
width: 120,
sortable: true,
renderer: function(v, metaData, record) {
let tfa_type = PVE.Parser.parseTfaType(v);
if (tfa_type === undefined) {
return Proxmox.Utils.noText;
}
if (tfa_type !== 1) {
return tfa_type;
}
let locked_until = record.data['tfa-locked-until'];
if (locked_until !== undefined) {
let now = new Date().getTime() / 1000;
if (locked_until > now) {
return gettext('Locked');
}
}
if (record.data['totp-locked']) {
return gettext('TOTP Locked');
}
return Proxmox.Utils.yesText;
},
dataIndex: 'keys',
},
{
header: gettext('Groups'),
dataIndex: 'groups',
renderer: Ext.htmlEncode,
flex: 2,
},
{
header: gettext('Comment'),
sortable: false,
renderer: Ext.String.htmlEncode,
dataIndex: 'comment',
flex: 3,
},
],
listeners: {
activate: reload,
itemdblclick: run_editor,
},
});
me.callParent();
Proxmox.Utils.monStoreErrors(me, store);
},
});
Ext.define('PVE.dc.MetricServerView', {
extend: 'Ext.grid.Panel',
alias: ['widget.pveMetricServerView'],
stateful: true,
stateId: 'grid-metricserver',
controller: {
xclass: 'Ext.app.ViewController',
render_type: function(value) {
switch (value) {
case 'influxdb': return "InfluxDB";
case 'graphite': return "Graphite";
default: return Proxmox.Utils.unknownText;
}
},
editWindow: function(xtype, id) {
let me = this;
Ext.create(`PVE.dc.${xtype}Edit`, {
serverid: id,
autoShow: true,
listeners: {
destroy: () => me.reload(),
},
});
},
addServer: function(button) {
this.editWindow(button.text);
},
editServer: function() {
let me = this;
let view = me.getView();
let selection = view.getSelection();
if (!selection || selection.length < 1) {
return;
}
let cfg = selection[0].data;
let xtype = me.render_type(cfg.type);
me.editWindow(xtype, cfg.id);
},
reload: function() {
this.getView().getStore().load();
},
},
store: {
autoLoad: true,
id: 'metricservers',
proxy: {
type: 'proxmox',
url: '/api2/json/cluster/metrics/server',
},
},
columns: [
{
text: gettext('Name'),
flex: 2,
dataIndex: 'id',
},
{
text: gettext('Type'),
flex: 1,
dataIndex: 'type',
renderer: 'render_type',
},
{
text: gettext('Enabled'),
dataIndex: 'disable',
width: 100,
renderer: Proxmox.Utils.format_neg_boolean,
},
{
text: gettext('Server'),
width: 200,
dataIndex: 'server',
},
{
text: gettext('Port'),
width: 100,
dataIndex: 'port',
},
],
tbar: [
{
text: gettext('Add'),
menu: [
{
text: 'Graphite',
iconCls: 'fa fa-fw fa-bar-chart',
handler: 'addServer',
},
{
text: 'InfluxDB',
iconCls: 'fa fa-fw fa-bar-chart',
handler: 'addServer',
},
],
},
{
text: gettext('Edit'),
xtype: 'proxmoxButton',
handler: 'editServer',
disabled: true,
},
{
xtype: 'proxmoxStdRemoveButton',
baseurl: `/api2/extjs/cluster/metrics/server`,
callback: 'reload',
},
],
listeners: {
itemdblclick: 'editServer',
},
initComponent: function() {
var me = this;
me.callParent();
Proxmox.Utils.monStoreErrors(me, me.getStore());
},
});
Ext.define('PVE.dc.MetricServerBaseEdit', {
extend: 'Proxmox.window.Edit',
mixins: ['Proxmox.Mixin.CBind'],
cbindData: function() {
let me = this;
me.isCreate = !me.serverid;
me.serverid = me.serverid || "";
me.url = `/api2/extjs/cluster/metrics/server/${me.serverid}`;
me.method = me.isCreate ? 'POST' : 'PUT';
if (!me.isCreate) {
me.subject = `${me.subject}: ${me.serverid}`;
}
return {};
},
submitUrl: function(url, values) {
return this.isCreate ? `${url}/${values.id}` : url;
},
initComponent: function() {
let me = this;
me.callParent();
if (me.serverid) {
me.load({
success: function(response, options) {
let values = response.result.data;
values.enable = !values.disable;
me.down('inputpanel').setValues(values);
},
});
}
},
});
Ext.define('PVE.dc.InfluxDBEdit', {
extend: 'PVE.dc.MetricServerBaseEdit',
mixins: ['Proxmox.Mixin.CBind'],
onlineHelp: 'metric_server_influxdb',
subject: 'InfluxDB',
cbindData: function() {
let me = this;
me.callParent();
me.tokenEmptyText = me.isCreate ? '' : gettext('unchanged');
return {};
},
items: [
{
xtype: 'inputpanel',
cbind: {
isCreate: '{isCreate}',
},
onGetValues: function(values) {
let me = this;
values.disable = values.enable ? 0 : 1;
delete values.enable;
PVE.Utils.delete_if_default(values, 'verify-certificate', '1', me.isCreate);
return values;
},
column1: [
{
xtype: 'hidden',
name: 'type',
value: 'influxdb',
cbind: {
submitValue: '{isCreate}',
},
},
{
xtype: 'pmxDisplayEditField',
name: 'id',
fieldLabel: gettext('Name'),
allowBlank: false,
cbind: {
editable: '{isCreate}',
value: '{serverid}',
},
},
{
xtype: 'proxmoxtextfield',
name: 'server',
fieldLabel: gettext('Server'),
allowBlank: false,
},
{
xtype: 'proxmoxintegerfield',
name: 'port',
fieldLabel: gettext('Port'),
value: 8089,
minValue: 1,
maximum: 65536,
allowBlank: false,
},
{
xtype: 'proxmoxKVComboBox',
name: 'influxdbproto',
fieldLabel: gettext('Protocol'),
value: '__default__',
cbind: {
deleteEmpty: '{!isCreate}',
},
comboItems: [
['__default__', 'UDP'],
['http', 'HTTP'],
['https', 'HTTPS'],
],
listeners: {
change: function(field, value) {
let me = this;
let view = me.up('inputpanel');
let isUdp = value !== 'http' && value !== 'https';
view.down('field[name=organization]').setDisabled(isUdp);
view.down('field[name=bucket]').setDisabled(isUdp);
view.down('field[name=token]').setDisabled(isUdp);
view.down('field[name=api-path-prefix]').setDisabled(isUdp);
view.down('field[name=mtu]').setDisabled(!isUdp);
view.down('field[name=timeout]').setDisabled(isUdp);
view.down('field[name=max-body-size]').setDisabled(isUdp);
view.down('field[name=verify-certificate]').setDisabled(value !== 'https');
},
},
},
],
column2: [
{
xtype: 'checkbox',
name: 'enable',
fieldLabel: gettext('Enabled'),
inputValue: 1,
uncheckedValue: 0,
checked: true,
},
{
xtype: 'proxmoxtextfield',
name: 'organization',
fieldLabel: gettext('Organization'),
emptyText: 'proxmox',
disabled: true,
cbind: {
deleteEmpty: '{!isCreate}',
},
},
{
xtype: 'proxmoxtextfield',
name: 'bucket',
fieldLabel: gettext('Bucket'),
emptyText: 'proxmox',
disabled: true,
cbind: {
deleteEmpty: '{!isCreate}',
},
},
{
xtype: 'proxmoxtextfield',
name: 'token',
fieldLabel: gettext('Token'),
disabled: true,
allowBlank: true,
deleteEmpty: false,
submitEmpty: false,
cbind: {
disabled: '{!isCreate}',
emptyText: '{tokenEmptyText}',
},
},
],
advancedColumn1: [
{
xtype: 'proxmoxtextfield',
name: 'api-path-prefix',
fieldLabel: gettext('API Path Prefix'),
allowBlank: true,
disabled: true,
cbind: {
deleteEmpty: '{!isCreate}',
},
},
{
xtype: 'proxmoxintegerfield',
name: 'timeout',
fieldLabel: gettext('Timeout (s)'),
disabled: true,
cbind: {
deleteEmpty: '{!isCreate}',
},
minValue: 1,
emptyText: 1,
},
{
xtype: 'proxmoxcheckbox',
name: 'verify-certificate',
fieldLabel: gettext('Verify Certificate'),
value: 1,
uncheckedValue: 0,
disabled: true,
},
],
advancedColumn2: [
{
xtype: 'proxmoxintegerfield',
name: 'max-body-size',
fieldLabel: gettext('Batch Size (b)'),
minValue: 1,
emptyText: '25000000',
submitEmpty: false,
cbind: {
deleteEmpty: '{!isCreate}',
},
},
{
xtype: 'proxmoxintegerfield',
name: 'mtu',
fieldLabel: 'MTU',
minValue: 1,
emptyText: '1500',
submitEmpty: false,
cbind: {
deleteEmpty: '{!isCreate}',
},
},
],
},
],
});
Ext.define('PVE.dc.GraphiteEdit', {
extend: 'PVE.dc.MetricServerBaseEdit',
mixins: ['Proxmox.Mixin.CBind'],
onlineHelp: 'metric_server_graphite',
subject: 'Graphite',
items: [
{
xtype: 'inputpanel',
onGetValues: function(values) {
values.disable = values.enable ? 0 : 1;
delete values.enable;
return values;
},
column1: [
{
xtype: 'hidden',
name: 'type',
value: 'graphite',
cbind: {
submitValue: '{isCreate}',
},
},
{
xtype: 'pmxDisplayEditField',
name: 'id',
fieldLabel: gettext('Name'),
allowBlank: false,
cbind: {
editable: '{isCreate}',
value: '{serverid}',
},
},
{
xtype: 'proxmoxtextfield',
name: 'server',
fieldLabel: gettext('Server'),
allowBlank: false,
},
],
column2: [
{
xtype: 'checkbox',
name: 'enable',
fieldLabel: gettext('Enabled'),
inputValue: 1,
uncheckedValue: 0,
checked: true,
},
{
xtype: 'proxmoxintegerfield',
name: 'port',
fieldLabel: gettext('Port'),
value: 2003,
minimum: 1,
maximum: 65536,
allowBlank: false,
},
{
fieldLabel: gettext('Path'),
xtype: 'proxmoxtextfield',
emptyText: 'proxmox',
name: 'path',
cbind: {
deleteEmpty: '{!isCreate}',
},
},
],
advancedColumn1: [
{
xtype: 'proxmoxKVComboBox',
name: 'proto',
fieldLabel: gettext('Protocol'),
value: '__default__',
cbind: {
deleteEmpty: '{!isCreate}',
},
comboItems: [
['__default__', 'UDP'],
['tcp', 'TCP'],
],
listeners: {
change: function(field, value) {
let me = this;
me.up('inputpanel').down('field[name=timeout]').setDisabled(value !== 'tcp');
me.up('inputpanel').down('field[name=mtu]').setDisabled(value === 'tcp');
},
},
},
],
advancedColumn2: [
{
xtype: 'proxmoxintegerfield',
name: 'mtu',
fieldLabel: 'MTU',
minimum: 1,
emptyText: '1500',
submitEmpty: false,
cbind: {
deleteEmpty: '{!isCreate}',
},
},
{
xtype: 'proxmoxintegerfield',
name: 'timeout',
fieldLabel: gettext('TCP Timeout'),
disabled: true,
cbind: {
deleteEmpty: '{!isCreate}',
},
minValue: 1,
emptyText: 1,
},
],
},
],
});
Ext.define('PVE.dc.UserTagAccessEdit', {
extend: 'Proxmox.window.Edit',
alias: 'widget.pveUserTagAccessEdit',
subject: gettext('User Tag Access'),
onlineHelp: 'datacenter_configuration_file',
url: '/api2/extjs/cluster/options',
hintText: gettext('NOTE: The following tags are also defined as registered tags.'),
controller: {
xclass: 'Ext.app.ViewController',
tagChange: function(field, value) {
let me = this;
let view = me.getView();
let also_registered = [];
value = Ext.isArray(value) ? value : value.split(';');
value.forEach(tag => {
if (view.registered_tags.indexOf(tag) !== -1) {
also_registered.push(tag);
}
});
let hint_field = me.lookup('hintField');
hint_field.setVisible(also_registered.length > 0);
if (also_registered.length > 0) {
hint_field.setValue(`${view.hintText} ${also_registered.join(', ')}`);
}
},
},
items: [
{
xtype: 'inputpanel',
setValues: function(values) {
this.up('pveUserTagAccessEdit').registered_tags = values?.['registered-tags'] ?? [];
let data = values?.['user-tag-access'] ?? {};
return Proxmox.panel.InputPanel.prototype.setValues.call(this, data);
},
onGetValues: function(values) {
if (values === undefined || Object.keys(values).length === 0) {
return { 'delete': 'user-tag-access' };
}
return {
'user-tag-access': PVE.Parser.printPropertyString(values),
};
},
items: [
{
name: 'user-allow',
fieldLabel: gettext('Mode'),
xtype: 'proxmoxKVComboBox',
deleteEmpty: false,
value: '__default__',
comboItems: [
['__default__', Proxmox.Utils.defaultText + ' (free)'],
['free', 'free'],
['existing', 'existing'],
['list', 'list'],
['none', 'none'],
],
defaultValue: '__default__',
},
{
xtype: 'displayfield',
fieldLabel: gettext('Predefined Tags'),
},
{
name: 'user-allow-list',
xtype: 'pveListField',
emptyText: gettext('No Tags defined'),
fieldTitle: gettext('Tag'),
maskRe: PVE.Utils.tagCharRegex,
gridConfig: {
height: 200,
scrollable: true,
},
listeners: {
change: 'tagChange',
},
},
{
hidden: true,
xtype: 'displayfield',
reference: 'hintField',
userCls: 'pmx-hint',
},
],
},
],
});
Ext.define('PVE.dc.RegisteredTagsEdit', {
extend: 'Proxmox.window.Edit',
alias: 'widget.pveRegisteredTagEdit',
subject: gettext('Registered Tags'),
onlineHelp: 'datacenter_configuration_file',
url: '/api2/extjs/cluster/options',
hintText: gettext('NOTE: The following tags are also defined in the user allow list.'),
controller: {
xclass: 'Ext.app.ViewController',
tagChange: function(field, value) {
let me = this;
let view = me.getView();
let also_allowed = [];
value = Ext.isArray(value) ? value : value.split(';');
value.forEach(tag => {
if (view.allowed_tags.indexOf(tag) !== -1) {
also_allowed.push(tag);
}
});
let hint_field = me.lookup('hintField');
hint_field.setVisible(also_allowed.length > 0);
if (also_allowed.length > 0) {
hint_field.setValue(`${view.hintText} ${also_allowed.join(', ')}`);
}
},
},
items: [
{
xtype: 'inputpanel',
setValues: function(values) {
let allowed_tags = values?.['user-tag-access']?.['user-allow-list'] ?? [];
this.up('pveRegisteredTagEdit').allowed_tags = allowed_tags;
let tags = values?.['registered-tags'];
return Proxmox.panel.InputPanel.prototype.setValues.call(this, { tags });
},
onGetValues: function(values) {
if (!values.tags) {
return {
'delete': 'registered-tags',
};
} else {
return {
'registered-tags': values.tags,
};
}
},
items: [
{
name: 'tags',
xtype: 'pveListField',
maskRe: PVE.Utils.tagCharRegex,
gridConfig: {
height: 200,
scrollable: true,
emptyText: gettext('No Tags defined'),
},
listeners: {
change: 'tagChange',
},
},
{
hidden: true,
xtype: 'displayfield',
reference: 'hintField',
userCls: 'pmx-hint',
},
],
},
],
});
Ext.define('PVE.dc.RealmSyncJobView', {
extend: 'Ext.grid.Panel',
alias: 'widget.pveRealmSyncJobView',
stateful: true,
stateId: 'grid-realmsyncjobs',
emptyText: Ext.String.format(gettext('No {0} configured'), gettext('Realm Sync Job')),
controller: {
xclass: 'Ext.app.ViewController',
addRealmSyncJob: function(button) {
let me = this;
Ext.create(`PVE.dc.RealmSyncJobEdit`, {
autoShow: true,
listeners: {
destroy: () => me.reload(),
},
});
},
editRealmSyncJob: function() {
let me = this;
let view = me.getView();
let selection = view.getSelection();
if (!selection || selection.length < 1) {
return;
}
Ext.create(`PVE.dc.RealmSyncJobEdit`, {
jobid: selection[0].data.id,
autoShow: true,
listeners: {
destroy: () => me.reload(),
},
});
},
runNow: function() {
let me = this;
let view = me.getView();
let selection = view.getSelection();
if (!selection || selection.length < 1) {
return;
}
let params = selection[0].data;
let realm = params.realm;
let propertiesToDelete = ['comment', 'realm', 'id', 'type', 'schedule', 'last-run', 'next-run', 'enabled'];
for (const prop of propertiesToDelete) {
delete params[prop];
}
Proxmox.Utils.API2Request({
url: `/access/domains/${realm}/sync`,
params,
waitMsgTarget: view,
method: 'POST',
failure: response => Ext.Msg.alert(gettext('Error'), response.htmlStatus),
success: function(response, options) {
Ext.create('Proxmox.window.TaskProgress', {
autoShow: true,
upid: response.result.data,
taskDone: () => { me.reload(); },
});
},
});
},
reload: function() {
this.getView().getStore().load();
},
},
store: {
autoLoad: true,
id: 'realm-syncs',
proxy: {
type: 'proxmox',
url: '/api2/json/cluster/jobs/realm-sync',
},
},
viewConfig: {
getRowClass: (record, _index) => record.get('enabled') ? '' : 'proxmox-disabled-row',
},
columns: [
{
header: gettext('Enabled'),
width: 80,
dataIndex: 'enabled',
sortable: true,
align: 'center',
stopSelection: false,
renderer: Proxmox.Utils.renderEnabledIcon,
},
{
text: gettext('Name'),
flex: 1,
dataIndex: 'id',
hidden: true,
},
{
text: gettext('Realm'),
width: 200,
dataIndex: 'realm',
},
{
header: gettext('Schedule'),
width: 150,
dataIndex: 'schedule',
},
{
text: gettext('Next Run'),
dataIndex: 'next-run',
width: 150,
renderer: PVE.Utils.render_next_event,
},
{
header: gettext('Comment'),
dataIndex: 'comment',
renderer: Ext.htmlEncode,
sorter: (a, b) => (a.data.comment || '').localeCompare(b.data.comment || ''),
flex: 1,
},
],
tbar: [
{
text: gettext('Add'),
handler: 'addRealmSyncJob',
},
{
text: gettext('Edit'),
xtype: 'proxmoxButton',
handler: 'editRealmSyncJob',
disabled: true,
},
{
xtype: 'proxmoxStdRemoveButton',
baseurl: `/api2/extjs/cluster/jobs/realm-sync`,
callback: 'reload',
},
{
xtype: 'proxmoxButton',
handler: 'runNow',
disabled: true,
text: gettext('Run Now'),
},
],
listeners: {
itemdblclick: 'editRealmSyncJob',
},
initComponent: function() {
var me = this;
me.callParent();
Proxmox.Utils.monStoreErrors(me, me.getStore());
},
});
Ext.define('PVE.dc.RealmSyncJobEdit', {
extend: 'Proxmox.window.Edit',
mixins: ['Proxmox.Mixin.CBind'],
subject: gettext('Realm Sync Job'),
onlineHelp: 'pveum_ldap_sync',
// don't focus the schedule field on edit
defaultFocus: 'field[name=id]',
cbindData: function() {
let me = this;
me.isCreate = !me.jobid;
me.jobid = me.jobid || "";
let url = '/api2/extjs/cluster/jobs/realm-sync';
me.url = me.jobid ? `${url}/${me.jobid}` : url;
me.method = me.isCreate ? 'POST' : 'PUT';
if (!me.isCreate) {
me.subject = `${me.subject}: ${me.jobid}`;
}
return {};
},
submitUrl: function(url, values) {
return this.isCreate ? `${url}/${values.id}` : url;
},
controller: {
xclass: 'Ext.app.ViewController',
updateDefaults: function(_field, newValue) {
let me = this;
['scope', 'enable-new', 'schedule'].forEach((reference) => {
me.lookup(reference)?.setDisabled(false);
});
// only update on create
if (!me.getView().isCreate) {
return;
}
Proxmox.Utils.API2Request({
url: `/access/domains/${newValue}`,
success: function(response) {
// first reset the fields to their default
['acl', 'entry', 'properties'].forEach(opt => {
me.lookup(`remove-vanished-${opt}`)?.setValue(false);
});
me.lookup('enable-new')?.setValue('1');
me.lookup('scope')?.setValue(undefined);
let options = response?.result?.data?.['sync-defaults-options'];
if (options) {
let parsed = PVE.Parser.parsePropertyString(options);
if (parsed['remove-vanished']) {
let opts = parsed['remove-vanished'].split(';');
for (const opt of opts) {
me.lookup(`remove-vanished-${opt}`)?.setValue(true);
}
delete parsed['remove-vanished'];
}
for (const [name, value] of Object.entries(parsed)) {
me.lookup(name)?.setValue(value);
}
}
},
});
},
},
items: [
{
xtype: 'inputpanel',
cbind: {
isCreate: '{isCreate}',
},
onGetValues: function(values) {
let me = this;
let vanished_opts = [];
['acl', 'entry', 'properties'].forEach((prop) => {
if (values[`remove-vanished-${prop}`]) {
vanished_opts.push(prop);
}
delete values[`remove-vanished-${prop}`];
});
if (!values.id && me.isCreate) {
values.id = 'realmsync-' + Ext.data.identifier.Uuid.Global.generate().slice(0, 13);
}
if (vanished_opts.length > 0) {
values['remove-vanished'] = vanished_opts.join(';');
} else {
values['remove-vanished'] = 'none';
}
PVE.Utils.delete_if_default(values, 'node', '');
if (me.isCreate) {
delete values.delete; // on create we cannot delete values
}
return values;
},
column1: [
{
xtype: 'pmxDisplayEditField',
editConfig: {
xtype: 'pmxRealmComboBox',
storeFilter: rec => rec.data.type === 'ldap' || rec.data.type === 'ad',
},
listConfig: {
emptyText: `${gettext('No LDAP/AD Realm found')}
`,
},
cbind: {
editable: '{isCreate}',
},
listeners: {
change: 'updateDefaults',
},
fieldLabel: gettext('Realm'),
name: 'realm',
reference: 'realm',
},
{
xtype: 'pveCalendarEvent',
fieldLabel: gettext('Schedule'),
disabled: true,
allowBlank: false,
name: 'schedule',
reference: 'schedule',
},
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Enable Job'),
name: 'enabled',
reference: 'enabled',
uncheckedValue: 0,
defaultValue: 1,
checked: true,
},
],
column2: [
{
xtype: 'proxmoxKVComboBox',
name: 'scope',
reference: 'scope',
disabled: true,
fieldLabel: gettext('Scope'),
value: '',
emptyText: gettext('No default available'),
deleteEmpty: false,
allowBlank: false,
comboItems: [
['users', gettext('Users')],
['groups', gettext('Groups')],
['both', gettext('Users and Groups')],
],
},
{
xtype: 'proxmoxKVComboBox',
value: '1',
deleteEmpty: false,
disabled: true,
allowBlank: false,
comboItems: [
['1', Proxmox.Utils.yesText],
['0', Proxmox.Utils.noText],
],
name: 'enable-new',
reference: 'enable-new',
fieldLabel: gettext('Enable New'),
},
],
columnB: [
{
xtype: 'fieldset',
title: gettext('Remove Vanished Options'),
items: [
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('ACL'),
name: 'remove-vanished-acl',
reference: 'remove-vanished-acl',
boxLabel: gettext('Remove ACLs of vanished users and groups.'),
},
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Entry'),
name: 'remove-vanished-entry',
reference: 'remove-vanished-entry',
boxLabel: gettext('Remove vanished user and group entries.'),
},
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Properties'),
name: 'remove-vanished-properties',
reference: 'remove-vanished-properties',
boxLabel: gettext('Remove vanished properties from synced users.'),
},
],
},
{
xtype: 'proxmoxtextfield',
name: 'comment',
fieldLabel: gettext('Job Comment'),
cbind: {
deleteEmpty: '{!isCreate}',
},
autoEl: {
tag: 'div',
'data-qtip': gettext('Description of the job'),
},
},
{
xtype: 'displayfield',
reference: 'defaulthint',
value: gettext('Default sync options can be set by editing the realm.'),
userCls: 'pmx-hint',
hidden: true,
},
],
},
],
initComponent: function() {
let me = this;
me.callParent();
if (me.jobid) {
me.load({
success: function(response, options) {
let values = response.result.data;
if (values['remove-vanished']) {
let opts = values['remove-vanished'].split(';');
for (const opt of opts) {
values[`remove-vanished-${opt}`] = 1;
}
}
me.down('inputpanel').setValues(values);
},
});
}
},
});
Ext.define('pve-resource-pci-tree', {
extend: 'Ext.data.Model',
idProperty: 'internalId',
fields: ['type', 'text', 'path', 'id', 'subsystem-id', 'iommugroup', 'description', 'digest'],
});
Ext.define('PVE.dc.PCIMapView', {
extend: 'PVE.tree.ResourceMapTree',
alias: 'widget.pveDcPCIMapView',
editWindowClass: 'PVE.window.PCIMapEditWindow',
baseUrl: '/cluster/mapping/pci',
mapIconCls: 'pve-itype-icon-pci',
getStatusCheckUrl: (node) => `/nodes/${node}/hardware/pci?pci-class-blacklist=`,
entryIdProperty: 'path',
checkValidity: function(data, node) {
let me = this;
let ids = {};
data.forEach((entry) => {
ids[entry.id] = entry;
});
me.getRootNode()?.cascade(function(rec) {
if (rec.data.node !== node || rec.data.type !== 'map') {
return;
}
let id = rec.data.path;
if (!id.match(/\.\d$/)) {
id += '.0';
}
let device = ids[id];
if (!device) {
rec.set('valid', 0);
rec.set('errmsg', Ext.String.format(gettext("Cannot find PCI id {0}"), id));
rec.commit();
return;
}
let deviceId = `${device.vendor}:${device.device}`.replace(/0x/g, '');
let subId = `${device.subsystem_vendor}:${device.subsystem_device}`.replace(/0x/g, '');
let toCheck = {
id: deviceId,
'subsystem-id': subId,
iommugroup: device.iommugroup !== -1 ? device.iommugroup : undefined,
};
let valid = 1;
let errors = [];
let errText = gettext("Configuration for {0} not correct ('{1}' != '{2}')");
for (const [key, validValue] of Object.entries(toCheck)) {
if (`${rec.data[key]}` !== `${validValue}`) {
errors.push(Ext.String.format(errText, key, rec.data[key] ?? '', validValue));
valid = 0;
}
}
rec.set('valid', valid);
rec.set('errmsg', errors.join('',
' ',
],
});
let tagsContainer = Ext.create('PVE.panel.TagEditContainer', {
tags: vm.tags,
canEdit: !!caps.vms['VM.Config.Options'],
listeners: {
change: function(tags) {
Proxmox.Utils.API2Request({
url: base_url + '/config',
method: 'PUT',
params: {
tags,
},
success: function() {
me.statusStore.load();
},
failure: function(response) {
Ext.Msg.alert('Error', response.htmlStatus);
me.statusStore.load();
},
});
},
},
});
let vm_text = `${vm.vmid} (${vm.name})`;
Ext.apply(me, {
title: Ext.String.format(gettext("Container {0} on node '{1}'"), vm_text, nodename),
hstateid: 'lxctab',
tbarSpacing: false,
tbar: [statusTxt, tagsContainer, '->', startBtn, shutdownBtn, migrateBtn, consoleBtn, moreBtn],
defaults: { statusStore: me.statusStore },
items: [
{
title: gettext('Summary'),
xtype: 'pveGuestSummary',
iconCls: 'fa fa-book',
itemId: 'summary',
},
],
});
if (caps.vms['VM.Console'] && !template) {
me.items.push(
{
title: gettext('Console'),
itemId: 'consolejs',
iconCls: 'fa fa-terminal',
xtype: 'pveNoVncConsole',
vmid: vmid,
consoleType: 'lxc',
xtermjs: true,
nodename: nodename,
},
);
}
me.items.push(
{
title: gettext('Resources'),
itemId: 'resources',
expandedOnInit: true,
iconCls: 'fa fa-cube',
xtype: 'pveLxcRessourceView',
},
{
title: gettext('Network'),
iconCls: 'fa fa-exchange',
itemId: 'network',
xtype: 'pveLxcNetworkView',
},
{
title: gettext('DNS'),
iconCls: 'fa fa-globe',
itemId: 'dns',
xtype: 'pveLxcDNS',
},
{
title: gettext('Options'),
itemId: 'options',
iconCls: 'fa fa-gear',
xtype: 'pveLxcOptions',
},
{
title: gettext('Task History'),
itemId: 'tasks',
iconCls: 'fa fa-list-alt',
xtype: 'proxmoxNodeTasks',
nodename: nodename,
preFilter: {
vmid,
},
},
);
if (caps.vms['VM.Backup']) {
me.items.push({
title: gettext('Backup'),
iconCls: 'fa fa-floppy-o',
xtype: 'pveBackupView',
itemId: 'backup',
},
{
title: gettext('Replication'),
iconCls: 'fa fa-retweet',
xtype: 'pveReplicaView',
itemId: 'replication',
});
}
if ((caps.vms['VM.Snapshot'] || caps.vms['VM.Snapshot.Rollback'] ||
caps.vms['VM.Audit']) && !template) {
me.items.push({
title: gettext('Snapshots'),
iconCls: 'fa fa-history',
xtype: 'pveGuestSnapshotTree',
type: 'lxc',
itemId: 'snapshot',
});
}
if (caps.vms['VM.Audit']) {
me.items.push(
{
xtype: 'pveFirewallRules',
title: gettext('Firewall'),
iconCls: 'fa fa-shield',
allow_iface: true,
base_url: base_url + '/firewall/rules',
list_refs_url: base_url + '/firewall/refs',
itemId: 'firewall',
},
{
xtype: 'pveFirewallOptions',
groups: ['firewall'],
iconCls: 'fa fa-gear',
onlineHelp: 'pve_firewall_vm_container_configuration',
title: gettext('Options'),
base_url: base_url + '/firewall/options',
fwtype: 'vm',
itemId: 'firewall-options',
},
{
xtype: 'pveFirewallAliases',
title: gettext('Alias'),
groups: ['firewall'],
iconCls: 'fa fa-external-link',
base_url: base_url + '/firewall/aliases',
itemId: 'firewall-aliases',
},
{
xtype: 'pveIPSet',
title: gettext('IPSet'),
groups: ['firewall'],
iconCls: 'fa fa-list-ol',
base_url: base_url + '/firewall/ipset',
list_refs_url: base_url + '/firewall/refs',
itemId: 'firewall-ipset',
},
);
}
if (caps.vms['VM.Console']) {
me.items.push(
{
title: gettext('Log'),
groups: ['firewall'],
iconCls: 'fa fa-list',
onlineHelp: 'chapter_pve_firewall',
itemId: 'firewall-fwlog',
xtype: 'proxmoxLogView',
url: '/api2/extjs' + base_url + '/firewall/log',
},
);
}
if (caps.vms['Permissions.Modify']) {
me.items.push({
xtype: 'pveACLView',
title: gettext('Permissions'),
itemId: 'permissions',
iconCls: 'fa fa-unlock',
path: '/vms/' + vmid,
});
}
me.callParent();
var prevStatus = 'unknown';
me.mon(me.statusStore, 'load', function(s, records, success) {
var status;
var lock;
var rec;
if (!success) {
status = 'unknown';
} else {
rec = s.data.get('status');
status = rec ? rec.data.value : 'unknown';
rec = s.data.get('template');
template = rec ? rec.data.value : false;
rec = s.data.get('lock');
lock = rec ? rec.data.value : undefined;
}
statusTxt.update({ lock: lock });
rec = s.data.get('tags');
tagsContainer.loadTags(rec?.data?.value);
startBtn.setDisabled(!caps.vms['VM.PowerMgmt'] || status === 'running' || template);
shutdownBtn.setDisabled(!caps.vms['VM.PowerMgmt'] || status !== 'running');
me.down('#removeBtn').setDisabled(!caps.vms['VM.Allocate'] || status !== 'stopped');
consoleBtn.setDisabled(template);
if (prevStatus === 'stopped' && status === 'running') {
let con = me.down('#consolejs');
if (con) {
con.reload();
}
}
prevStatus = status;
});
me.on('afterrender', function() {
me.statusStore.startUpdate();
});
me.on('destroy', function() {
me.statusStore.stopUpdate();
});
},
});
Ext.define('PVE.lxc.CreateWizard', {
extend: 'PVE.window.Wizard',
mixins: ['Proxmox.Mixin.CBind'],
viewModel: {
data: {
nodename: '',
storage: '',
unprivileged: true,
},
formulas: {
cgroupMode: function(get) {
const nodeInfo = PVE.data.ResourceStore.getNodes().find(
node => node.node === get('nodename'),
);
return nodeInfo ? nodeInfo['cgroup-mode'] : 2;
},
},
},
cbindData: {
nodename: undefined,
},
subject: gettext('LXC Container'),
items: [
{
xtype: 'inputpanel',
title: gettext('General'),
onlineHelp: 'pct_general',
column1: [
{
xtype: 'pveNodeSelector',
name: 'nodename',
cbind: {
selectCurNode: '{!nodename}',
preferredValue: '{nodename}',
},
bind: {
value: '{nodename}',
},
fieldLabel: gettext('Node'),
allowBlank: false,
onlineValidator: true,
},
{
xtype: 'pveGuestIDSelector',
name: 'vmid', // backend only knows vmid
guestType: 'lxc',
value: '',
loadNextFreeID: true,
validateExists: false,
},
{
xtype: 'proxmoxtextfield',
name: 'hostname',
vtype: 'DnsName',
value: '',
fieldLabel: gettext('Hostname'),
skipEmptyText: true,
allowBlank: true,
},
{
xtype: 'proxmoxcheckbox',
name: 'unprivileged',
value: true,
bind: {
value: '{unprivileged}',
},
fieldLabel: gettext('Unprivileged container'),
},
{
xtype: 'proxmoxcheckbox',
name: 'features',
inputValue: 'nesting=1',
value: true,
bind: {
disabled: '{!unprivileged}',
},
fieldLabel: gettext('Nesting'),
},
],
column2: [
{
xtype: 'pvePoolSelector',
fieldLabel: gettext('Resource Pool'),
name: 'pool',
value: '',
allowBlank: true,
},
{
xtype: 'textfield',
inputType: 'password',
name: 'password',
value: '',
fieldLabel: gettext('Password'),
allowBlank: false,
minLength: 5,
change: function(f, value) {
if (f.rendered) {
f.up().down('field[name=confirmpw]').validate();
}
},
},
{
xtype: 'textfield',
inputType: 'password',
name: 'confirmpw',
value: '',
fieldLabel: gettext('Confirm password'),
allowBlank: true,
submitValue: false,
validator: function(value) {
var pw = this.up().down('field[name=password]').getValue();
if (pw !== value) {
return "Passwords do not match!";
}
return true;
},
},
{
xtype: 'textarea',
name: 'ssh-public-keys',
value: '',
fieldLabel: gettext('SSH public key(s)'),
allowBlank: true,
validator: function(value) {
let pwfield = this.up().down('field[name=password]');
if (value.length) {
let keys = value.indexOf('\n') !== -1 ? value.split('\n') : [value];
if (keys.some(key => key !== '' && !PVE.Parser.parseSSHKey(key))) {
return "Failed to recognize ssh key";
}
pwfield.allowBlank = true;
} else {
pwfield.allowBlank = false;
}
pwfield.validate();
return true;
},
afterRender: function() {
if (!window.FileReader) {
return; // No FileReader support in this browser
}
let cancelEvent = ev => {
ev = ev.event;
if (ev.preventDefault) {
ev.preventDefault();
}
};
this.inputEl.on('dragover', cancelEvent);
this.inputEl.on('dragenter', cancelEvent);
this.inputEl.on('drop', ev => {
cancelEvent(ev);
let files = ev.event.dataTransfer.files;
PVE.Utils.loadSSHKeyFromFile(files[0], v => this.setValue(v));
});
},
},
{
xtype: 'pveMultiFileButton',
name: 'file',
hidden: !window.FileReader,
text: gettext('Load SSH Key File'),
listeners: {
change: function(btn, e, value) {
e = e.event;
let field = this.up().down('textarea[name=ssh-public-keys]');
for (const file of e?.target?.files ?? []) {
PVE.Utils.loadSSHKeyFromFile(file, v => {
let oldValue = field.getValue();
field.setValue(oldValue ? `${oldValue}\n${v.trim()}` : v.trim());
});
}
btn.reset();
},
},
},
],
advancedColumnB: [
{
xtype: 'pveTagFieldSet',
name: 'tags',
maxHeight: 150,
},
],
},
{
xtype: 'inputpanel',
title: gettext('Template'),
onlineHelp: 'pct_container_images',
column1: [
{
xtype: 'pveStorageSelector',
name: 'tmplstorage',
fieldLabel: gettext('Storage'),
storageContent: 'vztmpl',
autoSelect: true,
allowBlank: false,
bind: {
value: '{storage}',
nodename: '{nodename}',
},
},
{
xtype: 'pveFileSelector',
name: 'ostemplate',
storageContent: 'vztmpl',
fieldLabel: gettext('Template'),
bind: {
storage: '{storage}',
nodename: '{nodename}',
},
allowBlank: false,
},
],
},
{
xtype: 'pveMultiMPPanel',
title: gettext('Disks'),
insideWizard: true,
isCreate: true,
unused: false,
confid: 'rootfs',
},
{
xtype: 'pveLxcCPUInputPanel',
title: gettext('CPU'),
insideWizard: true,
},
{
xtype: 'pveLxcMemoryInputPanel',
title: gettext('Memory'),
insideWizard: true,
},
{
xtype: 'pveLxcNetworkInputPanel',
title: gettext('Network'),
insideWizard: true,
bind: {
nodename: '{nodename}',
},
isCreate: true,
},
{
xtype: 'pveLxcDNSInputPanel',
title: gettext('DNS'),
insideWizard: true,
},
{
title: gettext('Confirm'),
layout: 'fit',
items: [
{
xtype: 'grid',
store: {
model: 'KeyValue',
sorters: [{
property: 'key',
direction: 'ASC',
}],
},
columns: [
{ header: 'Key', width: 150, dataIndex: 'key' },
{ header: 'Value', flex: 1, dataIndex: 'value' },
],
},
],
dockedItems: [
{
xtype: 'proxmoxcheckbox',
name: 'start',
dock: 'bottom',
margin: '5 0 0 0',
boxLabel: gettext('Start after created'),
},
],
listeners: {
show: function(panel) {
let wizard = this.up('window');
let kv = wizard.getValues();
let data = [];
Ext.Object.each(kv, function(key, value) {
if (key === 'delete' || key === 'tmplstorage') { // ignore
return;
}
if (key === 'password') { // don't show pw
return;
}
data.push({ key: key, value: value });
});
let summaryStore = panel.down('grid').getStore();
summaryStore.suspendEvents();
summaryStore.removeAll();
summaryStore.add(data);
summaryStore.sort();
summaryStore.resumeEvents();
summaryStore.fireEvent('refresh');
},
},
onSubmit: function() {
let wizard = this.up('window');
let kv = wizard.getValues();
delete kv.delete;
let nodename = kv.nodename;
delete kv.nodename;
delete kv.tmplstorage;
if (!kv.pool.length) {
delete kv.pool;
}
if (!kv.password.length && kv['ssh-public-keys']) {
delete kv.password;
}
Proxmox.Utils.API2Request({
url: `/nodes/${nodename}/lxc`,
waitMsgTarget: wizard,
method: 'POST',
params: kv,
success: function(response, opts) {
Ext.create('Proxmox.window.TaskViewer', {
autoShow: true,
upid: response.result.data,
});
wizard.close();
},
failure: (response, opts) => Ext.Msg.alert(gettext('Error'), response.htmlStatus),
});
},
},
],
});
Ext.define('PVE.lxc.DNSInputPanel', {
extend: 'Proxmox.panel.InputPanel',
alias: 'widget.pveLxcDNSInputPanel',
insideWizard: false,
onGetValues: function(values) {
var me = this;
var deletes = [];
if (!values.searchdomain && !me.insideWizard) {
deletes.push('searchdomain');
}
if (values.nameserver) {
let list = values.nameserver.split(/[ ,;]+/);
values.nameserver = list.join(' ');
} else if (!me.insideWizard) {
deletes.push('nameserver');
}
if (deletes.length) {
values.delete = deletes.join(',');
}
return values;
},
initComponent: function() {
var me = this;
var items = [
{
xtype: 'proxmoxtextfield',
name: 'searchdomain',
skipEmptyText: true,
fieldLabel: gettext('DNS domain'),
emptyText: gettext('use host settings'),
allowBlank: true,
},
{
xtype: 'proxmoxtextfield',
fieldLabel: gettext('DNS servers'),
vtype: 'IP64AddressWithSuffixList',
allowBlank: true,
emptyText: gettext('use host settings'),
name: 'nameserver',
itemId: 'nameserver',
},
];
if (me.insideWizard) {
me.column1 = items;
} else {
me.items = items;
}
me.callParent();
},
});
Ext.define('PVE.lxc.DNSEdit', {
extend: 'Proxmox.window.Edit',
initComponent: function() {
var me = this;
var ipanel = Ext.create('PVE.lxc.DNSInputPanel');
Ext.apply(me, {
subject: gettext('Resources'),
items: [ipanel],
});
me.callParent();
if (!me.isCreate) {
me.load({
success: function(response, options) {
var values = response.result.data;
if (values.nameserver) {
values.nameserver.replace(/[,;]/, ' ');
values.nameserver.replace(/^\s+/, '');
}
ipanel.setValues(values);
},
});
}
},
});
Ext.define('PVE.lxc.DNS', {
extend: 'Proxmox.grid.PendingObjectGrid',
alias: ['widget.pveLxcDNS'],
onlineHelp: 'pct_container_network',
initComponent: function() {
var me = this;
var nodename = me.pveSelNode.data.node;
if (!nodename) {
throw "no node name specified";
}
var vmid = me.pveSelNode.data.vmid;
if (!vmid) {
throw "no VM ID specified";
}
var caps = Ext.state.Manager.get('GuiCap');
var rows = {
hostname: {
required: true,
defaultValue: me.pveSelNode.data.name,
header: gettext('Hostname'),
editor: caps.vms['VM.Config.Network'] ? {
xtype: 'proxmoxWindowEdit',
subject: gettext('Hostname'),
items: {
xtype: 'inputpanel',
items: {
fieldLabel: gettext('Hostname'),
xtype: 'textfield',
name: 'hostname',
vtype: 'DnsName',
allowBlank: true,
emptyText: 'CT' + vmid.toString(),
},
onGetValues: function(values) {
var params = values;
if (values.hostname === undefined ||
values.hostname === null ||
values.hostname === '') {
params = { hostname: 'CT'+vmid.toString() };
}
return params;
},
},
} : undefined,
},
searchdomain: {
header: gettext('DNS domain'),
defaultValue: '',
editor: caps.vms['VM.Config.Network'] ? 'PVE.lxc.DNSEdit' : undefined,
renderer: function(value) {
return value || gettext('use host settings');
},
},
nameserver: {
header: gettext('DNS server'),
defaultValue: '',
editor: caps.vms['VM.Config.Network'] ? 'PVE.lxc.DNSEdit' : undefined,
renderer: function(value) {
return value || gettext('use host settings');
},
},
};
var baseurl = 'nodes/' + nodename + '/lxc/' + vmid + '/config';
var reload = function() {
me.rstore.load();
};
var sm = Ext.create('Ext.selection.RowModel', {});
var run_editor = function() {
var rec = sm.getSelection()[0];
if (!rec) {
return;
}
var rowdef = rows[rec.data.key];
if (!rowdef.editor) {
return;
}
var win;
if (Ext.isString(rowdef.editor)) {
win = Ext.create(rowdef.editor, {
pveSelNode: me.pveSelNode,
confid: rec.data.key,
url: '/api2/extjs/nodes/' + nodename + '/lxc/' + vmid + '/config',
});
} else {
var config = Ext.apply({
pveSelNode: me.pveSelNode,
confid: rec.data.key,
url: '/api2/extjs/nodes/' + nodename + '/lxc/' + vmid + '/config',
}, rowdef.editor);
win = Ext.createWidget(rowdef.editor.xtype, config);
win.load();
}
//win.load();
win.show();
win.on('destroy', reload);
};
var edit_btn = new Proxmox.button.Button({
text: gettext('Edit'),
disabled: true,
selModel: sm,
enableFn: function(rec) {
var rowdef = rows[rec.data.key];
return !!rowdef.editor;
},
handler: run_editor,
});
var revert_btn = new PVE.button.PendingRevert();
var set_button_status = function() {
let button_sm = me.getSelectionModel();
let rec = button_sm.getSelection()[0];
if (!rec) {
edit_btn.disable();
return;
}
let key = rec.data.key;
let rowdef = rows[key];
edit_btn.setDisabled(!rowdef.editor);
let pending = rec.data.delete || me.hasPendingChanges(key);
revert_btn.setDisabled(!pending);
};
Ext.apply(me, {
url: "/api2/json/nodes/" + nodename + "/lxc/" + vmid + "/pending",
selModel: sm,
cwidth1: 150,
interval: 5000,
run_editor: run_editor,
tbar: [edit_btn, revert_btn],
rows: rows,
editorConfig: {
url: "/api2/extjs/" + baseurl,
},
listeners: {
itemdblclick: run_editor,
selectionchange: set_button_status,
activate: reload,
},
});
me.callParent();
me.on('activate', me.rstore.startUpdate);
me.on('destroy', me.rstore.stopUpdate);
me.on('deactivate', me.rstore.stopUpdate);
me.mon(me.getStore(), 'datachanged', function() {
set_button_status();
});
},
});
Ext.define('PVE.lxc.FeaturesInputPanel', {
extend: 'Proxmox.panel.InputPanel',
xtype: 'pveLxcFeaturesInputPanel',
// used to save the mounts fstypes until sending
mounts: [],
fstypes: ['nfs', 'cifs'],
viewModel: {
parent: null,
data: {
unprivileged: false,
},
formulas: {
privilegedOnly: function(get) {
return get('unprivileged') ? gettext('privileged only') : '';
},
unprivilegedOnly: function(get) {
return !get('unprivileged') ? gettext('unprivileged only') : '';
},
},
},
items: [
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('keyctl'),
name: 'keyctl',
bind: {
disabled: '{!unprivileged}',
boxLabel: '{unprivilegedOnly}',
},
},
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Nesting'),
name: 'nesting',
},
{
xtype: 'proxmoxcheckbox',
name: 'nfs',
fieldLabel: 'NFS',
bind: {
disabled: '{unprivileged}',
boxLabel: '{privilegedOnly}',
},
},
{
xtype: 'proxmoxcheckbox',
name: 'cifs',
fieldLabel: 'SMB/CIFS',
bind: {
disabled: '{unprivileged}',
boxLabel: '{privilegedOnly}',
},
},
{
xtype: 'proxmoxcheckbox',
name: 'fuse',
fieldLabel: 'FUSE',
},
{
xtype: 'proxmoxcheckbox',
name: 'mknod',
fieldLabel: gettext('Create Device Nodes'),
boxLabel: gettext('Experimental'),
},
],
onGetValues: function(values) {
var me = this;
var mounts = me.mounts;
me.fstypes.forEach(function(fs) {
if (values[fs]) {
mounts.push(fs);
}
delete values[fs];
});
if (mounts.length) {
values.mount = mounts.join(';');
}
var featuresstring = PVE.Parser.printPropertyString(values, undefined);
if (featuresstring === '') {
return { 'delete': 'features' };
}
return { features: featuresstring };
},
setValues: function(values) {
var me = this;
me.viewModel.set('unprivileged', values.unprivileged);
if (values.features) {
var res = PVE.Parser.parsePropertyString(values.features);
me.mounts = [];
if (res.mount) {
res.mount.split(/[; ]/).forEach(function(item) {
if (me.fstypes.indexOf(item) === -1) {
me.mounts.push(item);
} else {
res[item] = 1;
}
});
}
this.callParent([res]);
}
},
initComponent: function() {
let me = this;
me.mounts = []; // reset state
me.callParent();
},
});
Ext.define('PVE.lxc.FeaturesEdit', {
extend: 'Proxmox.window.Edit',
xtype: 'pveLxcFeaturesEdit',
subject: gettext('Features'),
autoLoad: true,
width: 350,
items: [{
xtype: 'pveLxcFeaturesInputPanel',
}],
});
Ext.define('PVE.lxc.MountPointInputPanel', {
extend: 'Proxmox.panel.InputPanel',
xtype: 'pveLxcMountPointInputPanel',
onlineHelp: 'pct_container_storage',
insideWizard: false,
unused: false, // add unused disk imaged
unprivileged: false,
vmconfig: {}, // used to select unused disks
setUnprivileged: function(unprivileged) {
var me = this;
var vm = me.getViewModel();
me.unprivileged = unprivileged;
vm.set('unpriv', unprivileged);
},
onGetValues: function(values) {
var me = this;
var confid = me.confid || "mp"+values.mpid;
me.mp.file = me.down('field[name=file]').getValue();
if (me.unused) {
confid = "mp"+values.mpid;
} else if (me.isCreate) {
me.mp.file = values.hdstorage + ':' + values.disksize;
}
// delete unnecessary fields
delete values.mpid;
delete values.hdstorage;
delete values.disksize;
delete values.diskformat;
let setMPOpt = (k, src, v) => PVE.Utils.propertyStringSet(me.mp, src, k, v);
setMPOpt('mp', values.mp);
let mountOpts = (values.mountoptions || []).join(';');
setMPOpt('mountoptions', values.mountoptions, mountOpts);
setMPOpt('mp', values.mp);
setMPOpt('backup', values.backup);
setMPOpt('quota', values.quota);
setMPOpt('ro', values.ro);
setMPOpt('acl', values.acl);
setMPOpt('replicate', values.replicate);
let res = {};
res[confid] = PVE.Parser.printLxcMountPoint(me.mp);
return res;
},
setMountPoint: function(mp) {
let me = this;
let vm = me.getViewModel();
vm.set('mptype', mp.type);
if (mp.mountoptions) {
mp.mountoptions = mp.mountoptions.split(';');
}
me.mp = mp;
me.filterMountOptions();
me.setValues(mp);
},
filterMountOptions: function() {
let me = this;
if (me.confid === 'rootfs') {
let field = me.down('field[name=mountoptions]');
let exclude = ['nodev', 'noexec'];
let filtered = field.comboItems.filter(v => !exclude.includes(v[0]));
field.setComboItems(filtered);
}
},
updateVMConfig: function(vmconfig) {
let me = this;
let vm = me.getViewModel();
me.vmconfig = vmconfig;
vm.set('unpriv', vmconfig.unprivileged);
me.down('field[name=mpid]').validate();
},
setVMConfig: function(vmconfig) {
let me = this;
me.updateVMConfig(vmconfig);
PVE.Utils.forEachMP((bus, i) => {
let name = "mp" + i.toString();
if (!Ext.isDefined(vmconfig[name])) {
me.down('field[name=mpid]').setValue(i);
return false;
}
return undefined;
});
},
setNodename: function(nodename) {
let me = this;
let vm = me.getViewModel();
vm.set('node', nodename);
me.down('#diskstorage').setNodename(nodename);
},
controller: {
xclass: 'Ext.app.ViewController',
control: {
'field[name=mpid]': {
change: function(field, value) {
let me = this;
let view = this.getView();
if (view.confid !== 'rootfs') {
view.fireEvent('diskidchange', view, `mp${value}`);
}
field.validate();
},
},
'#hdstorage': {
change: function(field, newValue) {
let me = this;
if (!newValue) {
return;
}
let rec = field.store.getById(newValue);
if (!rec) {
return;
}
me.getViewModel().set('type', rec.data.type);
},
},
},
init: function(view) {
let me = this;
let vm = this.getViewModel();
view.mp = {};
vm.set('confid', view.confid);
vm.set('unused', view.unused);
vm.set('node', view.nodename);
vm.set('unpriv', view.unprivileged);
vm.set('hideStorSelector', view.unused || !view.isCreate);
if (view.isCreate) { // can be array if created from unused disk
vm.set('isIncludedInBackup', true);
if (view.insideWizard) {
view.filterMountOptions();
}
}
if (view.selectFree) {
view.setVMConfig(view.vmconfig);
}
},
},
viewModel: {
data: {
unpriv: false,
unused: false,
showStorageSelector: false,
mptype: '',
type: '',
confid: '',
node: '',
},
formulas: {
quota: function(get) {
return !(get('type') === 'zfs' ||
get('type') === 'zfspool' ||
get('unpriv') ||
get('isBind'));
},
hasMP: function(get) {
return !!get('confid') && !get('unused');
},
isRoot: function(get) {
return get('confid') === 'rootfs';
},
isBind: function(get) {
return get('mptype') === 'bind';
},
isBindOrRoot: function(get) {
return get('isBind') || get('isRoot');
},
},
},
column1: [
{
xtype: 'proxmoxintegerfield',
name: 'mpid',
fieldLabel: gettext('Mount Point ID'),
minValue: 0,
maxValue: PVE.Utils.mp_counts.mp - 1,
hidden: true,
allowBlank: false,
disabled: true,
bind: {
hidden: '{hasMP}',
disabled: '{hasMP}',
},
validator: function(value) {
let view = this.up('inputpanel');
if (!view.rendered) {
return undefined;
}
if (Ext.isDefined(view.vmconfig["mp"+value])) {
return "Mount point is already in use.";
}
return true;
},
},
{
xtype: 'pveDiskStorageSelector',
itemId: 'diskstorage',
storageContent: 'rootdir',
hidden: true,
autoSelect: true,
selectformat: false,
defaultSize: 8,
bind: {
hidden: '{hideStorSelector}',
disabled: '{hideStorSelector}',
nodename: '{node}',
},
},
{
xtype: 'textfield',
disabled: true,
submitValue: false,
fieldLabel: gettext('Disk image'),
name: 'file',
bind: {
hidden: '{!hideStorSelector}',
},
},
],
column2: [
{
xtype: 'textfield',
name: 'mp',
value: '',
emptyText: gettext('/some/path'),
allowBlank: false,
disabled: true,
fieldLabel: gettext('Path'),
bind: {
hidden: '{isRoot}',
disabled: '{isRoot}',
},
},
{
xtype: 'proxmoxcheckbox',
name: 'backup',
fieldLabel: gettext('Backup'),
autoEl: {
tag: 'div',
'data-qtip': gettext('Include volume in backup job'),
},
bind: {
hidden: '{isRoot}',
disabled: '{isBindOrRoot}',
value: '{isIncludedInBackup}',
},
},
],
advancedColumn1: [
{
xtype: 'proxmoxcheckbox',
name: 'quota',
defaultValue: 0,
bind: {
disabled: '{!quota}',
},
fieldLabel: gettext('Enable quota'),
listeners: {
disable: function() {
this.reset();
},
},
},
{
xtype: 'proxmoxcheckbox',
name: 'ro',
defaultValue: 0,
bind: {
hidden: '{isRoot}',
disabled: '{isRoot}',
},
fieldLabel: gettext('Read-only'),
},
{
xtype: 'proxmoxKVComboBox',
name: 'mountoptions',
fieldLabel: gettext('Mount options'),
deleteEmpty: false,
comboItems: [
['lazytime', 'lazytime'],
['noatime', 'noatime'],
['nodev', 'nodev'],
['noexec', 'noexec'],
['nosuid', 'nosuid'],
],
multiSelect: true,
value: [],
allowBlank: true,
},
],
advancedColumn2: [
{
xtype: 'proxmoxKVComboBox',
name: 'acl',
fieldLabel: 'ACLs',
deleteEmpty: false,
comboItems: [
['__default__', Proxmox.Utils.defaultText],
['1', Proxmox.Utils.enabledText],
['0', Proxmox.Utils.disabledText],
],
value: '__default__',
bind: {
disabled: '{isBind}',
},
allowBlank: true,
},
{
xtype: 'proxmoxcheckbox',
inputValue: '0', // reverses the logic
name: 'replicate',
fieldLabel: gettext('Skip replication'),
},
],
});
Ext.define('PVE.lxc.MountPointEdit', {
extend: 'Proxmox.window.Edit',
unprivileged: false,
initComponent: function() {
let me = this;
let nodename = me.pveSelNode.data.node;
if (!nodename) {
throw "no node name specified";
}
let unused = me.confid && me.confid.match(/^unused\d+$/);
me.isCreate = me.confid ? unused : true;
let ipanel = Ext.create('PVE.lxc.MountPointInputPanel', {
confid: me.confid,
nodename: nodename,
unused: unused,
unprivileged: me.unprivileged,
isCreate: me.isCreate,
});
let subject;
if (unused) {
subject = gettext('Unused Disk');
} else if (me.isCreate) {
subject = gettext('Mount Point');
} else {
subject = gettext('Mount Point') + ' (' + me.confid + ')';
}
Ext.apply(me, {
subject: subject,
defaultFocus: me.confid !== 'rootfs' ? 'textfield[name=mp]' : 'tool',
items: ipanel,
});
me.callParent();
me.load({
success: function(response, options) {
ipanel.setVMConfig(response.result.data);
if (me.confid) {
let value = response.result.data[me.confid];
let mp = PVE.Parser.parseLxcMountPoint(value);
if (!mp) {
Ext.Msg.alert(gettext('Error'), 'Unable to parse mount point options');
me.close();
return;
}
ipanel.setMountPoint(mp);
me.isValid(); // trigger validation
}
},
});
},
});
Ext.define('PVE.window.MPResize', {
extend: 'Ext.window.Window',
resizable: false,
resize_disk: function(disk, size) {
var me = this;
var params = { disk: disk, size: '+' + size + 'G' };
Proxmox.Utils.API2Request({
params: params,
url: '/nodes/' + me.nodename + '/lxc/' + me.vmid + '/resize',
waitMsgTarget: me,
method: 'PUT',
failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
},
success: function(response, opts) {
var upid = response.result.data;
var win = Ext.create('Proxmox.window.TaskViewer', { upid: upid });
win.show();
me.close();
},
});
},
initComponent: function() {
var me = this;
if (!me.nodename) {
throw "no node name specified";
}
if (!me.vmid) {
throw "no VM ID specified";
}
var items = [
{
xtype: 'displayfield',
name: 'disk',
value: me.disk,
fieldLabel: gettext('Disk'),
vtype: 'StorageId',
allowBlank: false,
},
];
me.hdsizesel = Ext.createWidget('numberfield', {
name: 'size',
minValue: 0,
maxValue: 128*1024,
decimalPrecision: 3,
value: '0',
fieldLabel: `${gettext('Size Increment')} (${gettext('GiB')})`,
allowBlank: false,
});
items.push(me.hdsizesel);
me.formPanel = Ext.create('Ext.form.Panel', {
bodyPadding: 10,
border: false,
fieldDefaults: {
labelWidth: 120,
anchor: '100%',
},
items: items,
});
var form = me.formPanel.getForm();
var submitBtn;
me.title = gettext('Resize disk');
submitBtn = Ext.create('Ext.Button', {
text: gettext('Resize disk'),
handler: function() {
if (form.isValid()) {
var values = form.getValues();
me.resize_disk(me.disk, values.size);
}
},
});
Ext.apply(me, {
modal: true,
border: false,
layout: 'fit',
buttons: [submitBtn],
items: [me.formPanel],
});
me.callParent();
},
});
Ext.define('PVE.lxc.NetworkInputPanel', {
extend: 'Proxmox.panel.InputPanel',
alias: 'widget.pveLxcNetworkInputPanel',
insideWizard: false,
onlineHelp: 'pct_container_network',
setNodename: function(nodename) {
let me = this;
if (!nodename || me.nodename === nodename) {
return;
}
me.nodename = nodename;
let bridgeSelector = me.query("[isFormField][name=bridge]")[0];
bridgeSelector.setNodename(nodename);
},
onGetValues: function(values) {
let me = this;
let id;
if (me.isCreate) {
id = values.id;
delete values.id;
} else {
id = me.ifname;
}
let newdata = {};
if (id) {
if (values.ipv6mode !== 'static') {
values.ip6 = values.ipv6mode;
}
if (values.ipv4mode !== 'static') {
values.ip = values.ipv4mode;
}
newdata[id] = PVE.Parser.printLxcNetwork(values);
}
return newdata;
},
initComponent: function() {
let me = this;
let cdata = {};
if (me.insideWizard) {
me.ifname = 'net0';
cdata.name = 'eth0';
me.dataCache = {};
}
cdata.firewall = me.insideWizard || me.isCreate;
if (!me.dataCache) {
throw "no dataCache specified";
}
if (!me.isCreate) {
if (!me.ifname) {
throw "no interface name specified";
}
if (!me.dataCache[me.ifname]) {
throw "no such interface '" + me.ifname + "'";
}
cdata = PVE.Parser.parseLxcNetwork(me.dataCache[me.ifname]);
}
for (let i = 0; i < 32; i++) {
let ifname = 'net' + i.toString();
if (me.isCreate && !me.dataCache[ifname]) {
me.ifname = ifname;
break;
}
}
me.column1 = [
{
xtype: 'hidden',
name: 'id',
value: me.ifname,
},
{
xtype: 'textfield',
name: 'name',
fieldLabel: gettext('Name'),
emptyText: '(e.g., eth0)',
allowBlank: false,
value: cdata.name,
validator: function(value) {
for (const [key, netRaw] of Object.entries(me.dataCache)) {
if (!key.match(/^net\d+/) || key === me.ifname) {
continue;
}
let net = PVE.Parser.parseLxcNetwork(netRaw);
if (net.name === value) {
return "interface name already in use";
}
}
return true;
},
},
{
xtype: 'textfield',
name: 'hwaddr',
fieldLabel: gettext('MAC address'),
vtype: 'MacAddress',
value: cdata.hwaddr,
allowBlank: true,
emptyText: 'auto',
},
{
xtype: 'PVE.form.BridgeSelector',
name: 'bridge',
nodename: me.nodename,
fieldLabel: gettext('Bridge'),
value: cdata.bridge,
allowBlank: false,
},
{
xtype: 'pveVlanField',
name: 'tag',
value: cdata.tag,
},
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Firewall'),
name: 'firewall',
value: cdata.firewall,
},
];
let dhcp4 = cdata.ip === 'dhcp';
if (dhcp4) {
cdata.ip = '';
cdata.gw = '';
}
let auto6 = cdata.ip6 === 'auto';
let dhcp6 = cdata.ip6 === 'dhcp';
if (auto6 || dhcp6) {
cdata.ip6 = '';
cdata.gw6 = '';
}
me.column2 = [
{
layout: {
type: 'hbox',
align: 'middle',
},
border: false,
margin: '0 0 5 0',
items: [
{
xtype: 'label',
text: 'IPv4:', // do not localize
},
{
xtype: 'radiofield',
boxLabel: gettext('Static'),
name: 'ipv4mode',
inputValue: 'static',
checked: !dhcp4,
margin: '0 0 0 10',
listeners: {
change: function(cb, value) {
me.down('field[name=ip]').setEmptyText(
value ? Proxmox.Utils.NoneText : "",
);
me.down('field[name=ip]').setDisabled(!value);
me.down('field[name=gw]').setDisabled(!value);
},
},
},
{
xtype: 'radiofield',
boxLabel: 'DHCP', // do not localize
name: 'ipv4mode',
inputValue: 'dhcp',
checked: dhcp4,
margin: '0 0 0 10',
},
],
},
{
xtype: 'textfield',
name: 'ip',
vtype: 'IPCIDRAddress',
value: cdata.ip,
emptyText: dhcp4 ? '' : Proxmox.Utils.NoneText,
disabled: dhcp4,
fieldLabel: 'IPv4/CIDR', // do not localize
},
{
xtype: 'textfield',
name: 'gw',
value: cdata.gw,
vtype: 'IPAddress',
disabled: dhcp4,
fieldLabel: gettext('Gateway') + ' (IPv4)',
margin: '0 0 3 0', // override bottom margin to account for the menuseparator
},
{
xtype: 'menuseparator',
height: '3',
margin: '0',
},
{
layout: {
type: 'hbox',
align: 'middle',
},
border: false,
margin: '0 0 5 0',
items: [
{
xtype: 'label',
text: 'IPv6:', // do not localize
},
{
xtype: 'radiofield',
boxLabel: gettext('Static'),
name: 'ipv6mode',
inputValue: 'static',
checked: !(auto6 || dhcp6),
margin: '0 0 0 10',
listeners: {
change: function(cb, value) {
me.down('field[name=ip6]').setEmptyText(
value ? Proxmox.Utils.NoneText : "",
);
me.down('field[name=ip6]').setDisabled(!value);
me.down('field[name=gw6]').setDisabled(!value);
},
},
},
{
xtype: 'radiofield',
boxLabel: 'DHCP', // do not localize
name: 'ipv6mode',
inputValue: 'dhcp',
checked: dhcp6,
margin: '0 0 0 10',
},
{
xtype: 'radiofield',
boxLabel: 'SLAAC', // do not localize
name: 'ipv6mode',
inputValue: 'auto',
checked: auto6,
margin: '0 0 0 10',
},
],
},
{
xtype: 'textfield',
name: 'ip6',
value: cdata.ip6,
emptyText: dhcp6 || auto6 ? '' : Proxmox.Utils.NoneText,
vtype: 'IP6CIDRAddress',
disabled: dhcp6 || auto6,
fieldLabel: 'IPv6/CIDR', // do not localize
},
{
xtype: 'textfield',
name: 'gw6',
vtype: 'IP6Address',
value: cdata.gw6,
disabled: dhcp6 || auto6,
fieldLabel: gettext('Gateway') + ' (IPv6)',
},
];
me.advancedColumn1 = [
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Disconnect'),
name: 'link_down',
value: cdata.link_down,
},
{
xtype: 'proxmoxintegerfield',
fieldLabel: 'MTU',
emptyText: gettext('Same as bridge'),
name: 'mtu',
value: cdata.mtu,
minValue: 576,
maxValue: 65535,
},
];
me.advancedColumn2 = [
{
xtype: 'numberfield',
name: 'rate',
fieldLabel: gettext('Rate limit') + ' (MB/s)',
minValue: 0,
maxValue: 10*1024,
value: cdata.rate,
emptyText: 'unlimited',
allowBlank: true,
},
];
me.callParent();
},
});
Ext.define('PVE.lxc.NetworkEdit', {
extend: 'Proxmox.window.Edit',
isAdd: true,
initComponent: function() {
let me = this;
if (!me.dataCache) {
throw "no dataCache specified";
}
if (!me.nodename) {
throw "no node name specified";
}
Ext.apply(me, {
subject: gettext('Network Device') + ' (veth)',
digest: me.dataCache.digest,
items: [
{
xtype: 'pveLxcNetworkInputPanel',
ifname: me.ifname,
nodename: me.nodename,
dataCache: me.dataCache,
isCreate: me.isCreate,
},
],
});
me.callParent();
},
});
Ext.define('PVE.lxc.NetworkView', {
extend: 'Ext.grid.GridPanel',
alias: 'widget.pveLxcNetworkView',
onlineHelp: 'pct_container_network',
dataCache: {}, // used to store result of last load
stateful: true,
stateId: 'grid-lxc-network',
load: function() {
let me = this;
Proxmox.Utils.setErrorMask(me, true);
Proxmox.Utils.API2Request({
url: me.url,
failure: function(response, opts) {
Proxmox.Utils.setErrorMask(me, gettext('Error') + ': ' + response.htmlStatus);
},
success: function(response, opts) {
Proxmox.Utils.setErrorMask(me, false);
let result = Ext.decode(response.responseText);
me.dataCache = result.data || {};
let records = [];
for (const [key, value] of Object.entries(me.dataCache)) {
if (key.match(/^net\d+/)) {
let net = PVE.Parser.parseLxcNetwork(value);
net.id = key;
records.push(net);
}
}
me.store.loadData(records);
me.down('button[name=addButton]').setDisabled(records.length >= 32);
},
});
},
initComponent: function() {
let me = this;
let nodename = me.pveSelNode.data.node;
if (!nodename) {
throw "no node name specified";
}
let vmid = me.pveSelNode.data.vmid;
if (!vmid) {
throw "no VM ID specified";
}
let caps = Ext.state.Manager.get('GuiCap');
me.url = `/nodes/${nodename}/lxc/${vmid}/config`;
let store = new Ext.data.Store({
model: 'pve-lxc-network',
sorters: [
{
property: 'id',
direction: 'ASC',
},
],
});
let sm = Ext.create('Ext.selection.RowModel', {});
let run_editor = function() {
let rec = sm.getSelection()[0];
if (!rec || !caps.vms['VM.Config.Network']) {
return false; // disable default-propagation when triggered by grid dblclick
}
Ext.create('PVE.lxc.NetworkEdit', {
url: me.url,
nodename: nodename,
dataCache: me.dataCache,
ifname: rec.data.id,
listeners: {
destroy: () => me.load(),
},
autoShow: true,
});
return undefined; // make eslint happier
};
Ext.apply(me, {
store: store,
selModel: sm,
tbar: [
{
text: gettext('Add'),
name: 'addButton',
disabled: !caps.vms['VM.Config.Network'],
handler: function() {
Ext.create('PVE.lxc.NetworkEdit', {
url: me.url,
nodename: nodename,
isCreate: true,
dataCache: me.dataCache,
listeners: {
destroy: () => me.load(),
},
autoShow: true,
});
},
},
{
xtype: 'proxmoxButton',
text: gettext('Remove'),
disabled: true,
selModel: sm,
enableFn: function(rec) {
return !!caps.vms['VM.Config.Network'];
},
confirmMsg: ({ data }) =>
Ext.String.format(gettext('Are you sure you want to remove entry {0}'), `'${data.id}'`),
handler: function(btn, e, rec) {
Proxmox.Utils.API2Request({
url: me.url,
waitMsgTarget: me,
method: 'PUT',
params: {
'delete': rec.data.id,
digest: me.dataCache.digest,
},
callback: () => me.load(),
failure: (response, opts) => Ext.Msg.alert(gettext('Error'), response.htmlStatus),
});
},
},
{
xtype: 'proxmoxButton',
text: gettext('Edit'),
selModel: sm,
disabled: true,
enableFn: rec => !!caps.vms['VM.Config.Network'],
handler: run_editor,
},
],
columns: [
{
header: 'ID',
width: 50,
dataIndex: 'id',
},
{
header: gettext('Name'),
width: 80,
dataIndex: 'name',
},
{
header: gettext('Bridge'),
width: 80,
dataIndex: 'bridge',
},
{
header: gettext('Firewall'),
width: 80,
dataIndex: 'firewall',
renderer: Proxmox.Utils.format_boolean,
},
{
header: gettext('VLAN Tag'),
width: 80,
dataIndex: 'tag',
},
{
header: gettext('MAC address'),
width: 110,
dataIndex: 'hwaddr',
},
{
header: gettext('IP address'),
width: 150,
dataIndex: 'ip',
renderer: function(value, metaData, rec) {
if (rec.data.ip && rec.data.ip6) {
return rec.data.ip + "Ceph?
"Ceph is a unified,
distributed storage system, designed for excellent performance, reliability,
and scalability."
Ceph is currently not installed on this node. This wizard
will guide you through the installation. Click on the next button below
to begin. After the initial installation, the wizard will offer to create
an initial configuration. This configuration step is only
needed once per cluster and will be skipped if a config is already present.
Before starting the installation, please take a look at our documentation,
by clicking the help button below. If you want to gain deeper knowledge about
Ceph, visit ceph.com .
`,
});
Ext.define('PVE.ceph.CephVersionSelector', {
extend: 'Ext.form.field.ComboBox',
xtype: 'pveCephVersionSelector',
fieldLabel: gettext('Ceph version to install'),
displayField: 'display',
valueField: 'release',
queryMode: 'local',
editable: false,
forceSelection: true,
store: {
fields: [
'release',
'version',
{
name: 'display',
calculate: d => `${d.release} (${d.version})`,
},
],
proxy: {
type: 'memory',
reader: {
type: 'json',
},
},
data: [
{ release: "quincy", version: "17.2" },
{ release: "reef", version: "18.2" },
],
},
});
Ext.define('PVE.ceph.CephHighestVersionDisplay', {
extend: 'Ext.form.field.Display',
xtype: 'pveCephHighestVersionDisplay',
fieldLabel: gettext('Ceph in the cluster'),
value: 'unknown',
// called on success with (release, versionTxt, versionParts)
gotNewestVersion: Ext.emptyFn,
initComponent: function() {
let me = this;
me.callParent(arguments);
Proxmox.Utils.API2Request({
method: 'GET',
url: '/cluster/ceph/metadata',
params: {
scope: 'versions',
},
waitMsgTarget: me,
success: (response) => {
let res = response.result;
if (!res || !res.data || !res.data.node) {
me.setValue(
gettext('Could not detect a ceph installation in the cluster'),
);
return;
}
let nodes = res.data.node;
if (me.nodename) {
// can happen on ceph purge, we do not yet cleanup old version data
delete nodes[me.nodename];
}
let maxversion = [];
let maxversiontext = "";
for (const [_nodename, data] of Object.entries(nodes)) {
let version = data.version.parts;
if (PVE.Utils.compare_ceph_versions(version, maxversion) > 0) {
maxversion = version;
maxversiontext = data.version.str;
}
}
// FIXME: get from version selector store
const major2release = {
13: 'luminous',
14: 'nautilus',
15: 'octopus',
16: 'pacific',
17: 'quincy',
18: 'reef',
19: 'squid',
};
let release = major2release[maxversion[0]] || 'unknown';
let newestVersionTxt = `${Ext.String.capitalize(release)} (${maxversiontext})`;
if (release === 'unknown') {
me.setValue(
gettext('Could not detect a ceph installation in the cluster'),
);
} else {
me.setValue(Ext.String.format(
gettext('Newest ceph version in cluster is {0}'),
newestVersionTxt,
));
}
me.gotNewestVersion(release, maxversiontext, maxversion);
},
failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
},
});
},
});
Ext.define('PVE.ceph.CephInstallWizard', {
extend: 'PVE.window.Wizard',
alias: 'widget.pveCephInstallWizard',
mixins: ['Proxmox.Mixin.CBind'],
resizable: false,
nodename: undefined,
width: 760, // 4:3
height: 570,
viewModel: {
data: {
nodename: '',
cephRelease: 'reef',
cephRepo: 'enterprise',
configuration: true,
isInstalled: false,
nodeHasSubscription: true, // avoid warning hint until fully loaded
allHaveSubscription: true, // avoid warning hint until fully loaded
},
formulas: {
repoHintHidden: get => get('allHaveSubscription') && get('cephRepo') === 'enterprise',
repoHint: function(get) {
let repo = get('cephRepo');
let nodeSub = get('nodeHasSubscription'), allSub = get('allHaveSubscription');
if (repo === 'enterprise') {
if (!nodeSub) {
return gettext('The enterprise repository is enabled, but there is no active subscription!');
} else if (!allSub) {
return gettext('Not all nodes have an active subscription, which is required for cluster-wide enterprise repo access');
}
return ''; // should be hidden
} else if (repo === 'no-subscription') {
return allSub
? gettext("Cluster has active subscriptions and would be elligible for using the enterprise repository.")
: gettext("The no-subscription repository is not the best choice for production setups.");
} else {
return gettext('The test repository should only be used for test setups or after consulting the official Proxmox support!');
}
},
},
},
cbindData: {
nodename: undefined,
},
title: gettext('Setup'),
navigateNext: function() {
var tp = this.down('#wizcontent');
var atab = tp.getActiveTab();
var next = tp.items.indexOf(atab) + 1;
var ntab = tp.items.getAt(next);
if (ntab) {
ntab.enable();
tp.setActiveTab(ntab);
}
},
setInitialTab: function(index) {
var tp = this.down('#wizcontent');
var initialTab = tp.items.getAt(index);
initialTab.enable();
tp.setActiveTab(initialTab);
},
onShow: function() {
this.callParent(arguments);
let viewModel = this.getViewModel();
var isInstalled = this.getViewModel().get('isInstalled');
if (isInstalled) {
viewModel.set('configuration', false);
this.setInitialTab(2);
}
PVE.Utils.getClusterSubscriptionLevel().then(subcriptionMap => {
viewModel.set('nodeHasSubscription', !!subcriptionMap[this.nodename]);
let allHaveSubscription = Object.values(subcriptionMap).every(level => !!level);
viewModel.set('allHaveSubscription', allHaveSubscription);
});
},
items: [
{
xtype: 'panel',
title: gettext('Info'),
viewModel: {}, // needed to inherit parent viewModel data
border: false,
bodyBorder: false,
onlineHelp: 'chapter_pveceph',
layout: {
type: 'vbox',
align: 'stretch',
},
defaults: {
border: false,
bodyBorder: false,
},
items: [
{
xtype: 'pveCephInstallWizardInfo',
},
{
flex: 1,
},
{
xtype: 'displayfield',
fieldLabel: gettext('Hint'),
labelClsExtra: 'pmx-hint',
submitValue: false,
labelWidth: 50,
bind: {
value: '{repoHint}',
hidden: '{repoHintHidden}',
},
},
{
xtype: 'pveCephHighestVersionDisplay',
labelWidth: 150,
cbind: {
nodename: '{nodename}',
},
gotNewestVersion: function(release, maxversiontext, maxversion) {
if (release === 'unknown') {
return;
}
let wizard = this.up('pveCephInstallWizard');
wizard.getViewModel().set('cephRelease', release);
},
},
{
xtype: 'container',
layout: 'hbox',
defaults: {
border: false,
layout: 'anchor',
flex: 1,
},
items: [{
xtype: 'pveCephVersionSelector',
labelWidth: 150,
padding: '0 10 0 0',
submitValue: false,
bind: {
value: '{cephRelease}',
},
listeners: {
change: function(field, release) {
let wizard = this.up('pveCephInstallWizard');
wizard.down('#next').setText(
Ext.String.format(gettext('Start {0} installation'), release),
);
},
},
},
{
xtype: 'proxmoxKVComboBox',
fieldLabel: gettext('Repository'),
padding: '0 0 0 10',
comboItems: [
['enterprise', gettext('Enterprise (recommended)')],
['no-subscription', gettext('No-Subscription')],
['test', gettext('Test')],
],
labelWidth: 150,
submitValue: false,
value: 'enterprise',
bind: {
value: '{cephRepo}',
},
}],
},
],
listeners: {
activate: function() {
// notify owning container that it should display a help button
if (this.onlineHelp) {
Ext.GlobalEvents.fireEvent('proxmoxShowHelp', this.onlineHelp);
}
let wizard = this.up('pveCephInstallWizard');
let release = wizard.getViewModel().get('cephRelease');
wizard.down('#back').hide(true);
wizard.down('#next').setText(
Ext.String.format(gettext('Start {0} installation'), release),
);
},
deactivate: function() {
if (this.onlineHelp) {
Ext.GlobalEvents.fireEvent('proxmoxHideHelp', this.onlineHelp);
}
this.up('pveCephInstallWizard').down('#next').setText(gettext('Next'));
},
},
},
{
title: gettext('Installation'),
xtype: 'panel',
layout: 'fit',
cbind: {
nodename: '{nodename}',
},
viewModel: {}, // needed to inherit parent viewModel data
listeners: {
afterrender: function() {
var me = this;
if (this.getViewModel().get('isInstalled')) {
this.mask("Ceph is already installed, click next to create your configuration.", ['pve-static-mask']);
} else {
me.down('pveNoVncConsole').fireEvent('activate');
}
},
activate: function() {
let me = this;
const nodename = me.nodename;
me.updateStore = Ext.create('Proxmox.data.UpdateStore', {
storeid: 'ceph-status-' + nodename,
interval: 1000,
proxy: {
type: 'proxmox',
url: '/api2/json/nodes/' + nodename + '/ceph/status',
},
listeners: {
load: function(rec, response, success, operation) {
if (success) {
me.updateStore.stopUpdate();
me.down('textfield').setValue('success');
} else if (operation.error.statusText.match("not initialized", "i")) {
me.updateStore.stopUpdate();
me.up('pveCephInstallWizard').getViewModel().set('configuration', false);
me.down('textfield').setValue('success');
} else if (operation.error.statusText.match("rados_connect failed", "i")) {
me.updateStore.stopUpdate();
me.up('pveCephInstallWizard').getViewModel().set('configuration', true);
me.down('textfield').setValue('success');
} else if (!operation.error.statusText.match("not installed", "i")) {
Proxmox.Utils.setErrorMask(me, operation.error.statusText);
}
},
},
});
me.updateStore.startUpdate();
},
destroy: function() {
var me = this;
if (me.updateStore) {
me.updateStore.stopUpdate();
}
},
},
items: [
{
xtype: 'pveNoVncConsole',
itemId: 'jsconsole',
consoleType: 'cmd',
xtermjs: true,
cbind: {
nodename: '{nodename}',
},
beforeLoad: function() {
let me = this;
let wizard = me.up('pveCephInstallWizard');
let release = wizard.getViewModel().get('cephRelease');
let repo = wizard.getViewModel().get('cephRepo');
me.cmdOpts = `--version\0${release}\0--repository\0${repo}`;
},
cmd: 'ceph_install',
},
{
xtype: 'textfield',
name: 'installSuccess',
value: '',
allowBlank: false,
submitValue: false,
hidden: true,
},
],
},
{
xtype: 'inputpanel',
title: gettext('Configuration'),
onlineHelp: 'chapter_pveceph',
height: 300,
cbind: {
nodename: '{nodename}',
},
viewModel: {
data: {
replicas: undefined,
minreplicas: undefined,
},
},
listeners: {
activate: function() {
this.up('pveCephInstallWizard').down('#submit').setText(gettext('Next'));
},
afterrender: function() {
if (this.up('pveCephInstallWizard').getViewModel().get('configuration')) {
this.mask("Configuration already initialized", ['pve-static-mask']);
} else {
this.unmask();
}
},
deactivate: function() {
this.up('pveCephInstallWizard').down('#submit').setText(gettext('Finish'));
},
},
column1: [
{
xtype: 'displayfield',
value: gettext('Ceph cluster configuration') + ':',
},
{
xtype: 'proxmoxNetworkSelector',
name: 'network',
value: '',
fieldLabel: 'Public Network IP/CIDR',
autoSelect: false,
bind: {
allowBlank: '{configuration}',
},
cbind: {
nodename: '{nodename}',
},
},
{
xtype: 'proxmoxNetworkSelector',
name: 'cluster-network',
fieldLabel: 'Cluster Network IP/CIDR',
allowBlank: true,
autoSelect: false,
emptyText: gettext('Same as Public Network'),
cbind: {
nodename: '{nodename}',
},
},
// FIXME: add hint about cluster network and/or reference user to docs??
],
column2: [
{
xtype: 'displayfield',
value: gettext('First Ceph monitor') + ':',
},
{
xtype: 'displayfield',
fieldLabel: gettext('Monitor node'),
cbind: {
value: '{nodename}',
},
},
{
xtype: 'displayfield',
value: gettext('Additional monitors are recommended. They can be created at any time in the Monitor tab.'),
userCls: 'pmx-hint',
},
],
advancedColumn1: [
{
xtype: 'numberfield',
name: 'size',
fieldLabel: 'Number of replicas',
bind: {
value: '{replicas}',
},
maxValue: 7,
minValue: 2,
emptyText: '3',
},
{
xtype: 'numberfield',
name: 'min_size',
fieldLabel: 'Minimum replicas',
bind: {
maxValue: '{replicas}',
value: '{minreplicas}',
},
minValue: 2,
maxValue: 3,
setMaxValue: function(value) {
this.maxValue = Ext.Number.from(value, 2);
// allow enough to avoid split brains with max 'size', but more makes simply no sense
if (this.maxValue > 4) {
this.maxValue = 4;
}
this.toggleSpinners();
this.validate();
},
emptyText: '2',
},
],
onGetValues: function(values) {
['cluster-network', 'size', 'min_size'].forEach(function(field) {
if (!values[field]) {
delete values[field];
}
});
return values;
},
onSubmit: function() {
var me = this;
if (!this.up('pveCephInstallWizard').getViewModel().get('configuration')) {
var wizard = me.up('window');
var kv = wizard.getValues();
delete kv.delete;
var nodename = me.nodename;
delete kv.nodename;
Proxmox.Utils.API2Request({
url: `/nodes/${nodename}/ceph/init`,
waitMsgTarget: wizard,
method: 'POST',
params: kv,
success: function() {
Proxmox.Utils.API2Request({
url: `/nodes/${nodename}/ceph/mon/${nodename}`,
waitMsgTarget: wizard,
method: 'POST',
success: function() {
me.up('pveCephInstallWizard').navigateNext();
},
failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
},
});
},
failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
},
});
} else {
me.up('pveCephInstallWizard').navigateNext();
}
},
},
{
title: gettext('Success'),
xtype: 'panel',
border: false,
bodyBorder: false,
onlineHelp: 'pve_ceph_install',
html: 'Installation successful! '+
'The basic installation and configuration is complete. Depending on your setup, some of the following steps are required to start using Ceph:
'+
'Install Ceph on other nodes '+
'Create additional Ceph Monitors '+
'Create Ceph OSDs '+
'Create Ceph Pools To learn more, click on the help button below.
',
listeners: {
activate: function() {
// notify owning container that it should display a help button
if (this.onlineHelp) {
Ext.GlobalEvents.fireEvent('proxmoxShowHelp', this.onlineHelp);
}
var tp = this.up('#wizcontent');
var idx = tp.items.indexOf(this)-1;
for (;idx >= 0; idx--) {
var nc = tp.items.getAt(idx);
if (nc) {
nc.disable();
}
}
},
deactivate: function() {
if (this.onlineHelp) {
Ext.GlobalEvents.fireEvent('proxmoxHideHelp', this.onlineHelp);
}
},
},
onSubmit: function() {
var wizard = this.up('pveCephInstallWizard');
wizard.close();
},
},
],
});
Ext.define('PVE.node.CephConfigDb', {
extend: 'Ext.grid.Panel',
alias: 'widget.pveNodeCephConfigDb',
border: false,
store: {
proxy: {
type: 'proxmox',
},
},
columns: [
{
dataIndex: 'section',
text: 'WHO',
width: 100,
},
{
dataIndex: 'mask',
text: 'MASK',
hidden: true,
width: 80,
},
{
dataIndex: 'level',
hidden: true,
text: 'LEVEL',
},
{
dataIndex: 'name',
flex: 1,
text: 'OPTION',
},
{
dataIndex: 'value',
flex: 1,
text: 'VALUE',
},
{
dataIndex: 'can_update_at_runtime',
text: 'Runtime Updatable',
hidden: true,
width: 80,
renderer: Proxmox.Utils.format_boolean,
},
],
initComponent: function() {
var me = this;
var nodename = me.pveSelNode.data.node;
if (!nodename) {
throw "no node name specified";
}
me.store.proxy.url = '/api2/json/nodes/' + nodename + '/ceph/cfg/db';
me.callParent();
Proxmox.Utils.monStoreErrors(me, me.getStore());
me.getStore().load();
},
});
Ext.define('PVE.node.CephConfig', {
extend: 'Ext.panel.Panel',
alias: 'widget.pveNodeCephConfig',
bodyStyle: 'white-space:pre',
bodyPadding: 5,
border: false,
scrollable: true,
load: function() {
var me = this;
Proxmox.Utils.API2Request({
url: me.url,
waitMsgTarget: me,
failure: function(response, opts) {
me.update(gettext('Error') + " " + response.htmlStatus);
var msg = response.htmlStatus;
PVE.Utils.showCephInstallOrMask(me.ownerCt, msg, me.pveSelNode.data.node,
function(win) {
me.mon(win, 'cephInstallWindowClosed', function() {
me.load();
});
},
);
},
success: function(response, opts) {
var data = response.result.data;
me.update(Ext.htmlEncode(data));
},
});
},
initComponent: function() {
var me = this;
var nodename = me.pveSelNode.data.node;
if (!nodename) {
throw "no node name specified";
}
Ext.apply(me, {
url: '/nodes/' + nodename + '/ceph/cfg/raw',
listeners: {
activate: function() {
me.load();
},
},
});
me.callParent();
me.load();
},
});
Ext.define('PVE.node.CephConfigCrush', {
extend: 'Ext.panel.Panel',
alias: 'widget.pveNodeCephConfigCrush',
onlineHelp: 'chapter_pveceph',
layout: 'border',
items: [{
title: gettext('Configuration'),
xtype: 'pveNodeCephConfig',
region: 'center',
},
{
title: 'Crush Map', // do not localize
xtype: 'pveNodeCephCrushMap',
region: 'east',
split: true,
width: '50%',
},
{
title: gettext('Configuration Database'),
xtype: 'pveNodeCephConfigDb',
region: 'south',
split: true,
weight: -30,
height: '50%',
}],
initComponent: function() {
var me = this;
me.defaults = {
pveSelNode: me.pveSelNode,
};
me.callParent();
},
});
Ext.define('PVE.node.CephCrushMap', {
extend: 'Ext.panel.Panel',
alias: ['widget.pveNodeCephCrushMap'],
bodyStyle: 'white-space:pre',
bodyPadding: 5,
border: false,
stateful: true,
stateId: 'layout-ceph-crush',
scrollable: true,
load: function() {
var me = this;
Proxmox.Utils.API2Request({
url: me.url,
waitMsgTarget: me,
failure: function(response, opts) {
me.update(gettext('Error') + " " + response.htmlStatus);
var msg = response.htmlStatus;
PVE.Utils.showCephInstallOrMask(
me.ownerCt,
msg,
me.pveSelNode.data.node,
win => me.mon(win, 'cephInstallWindowClosed', () => me.load()),
);
},
success: function(response, opts) {
var data = response.result.data;
me.update(Ext.htmlEncode(data));
},
});
},
initComponent: function() {
let me = this;
let nodename = me.pveSelNode.data.node;
if (!nodename) {
throw "no node name specified";
}
Ext.apply(me, {
url: `/nodes/${nodename}/ceph/crush`,
listeners: {
activate: () => me.load(),
},
});
me.callParent();
me.load();
},
});
Ext.define('PVE.CephCreateFS', {
extend: 'Proxmox.window.Edit',
alias: 'widget.pveCephCreateFS',
showTaskViewer: true,
onlineHelp: 'pveceph_fs_create',
subject: 'Ceph FS',
isCreate: true,
method: 'POST',
setFSName: function(fsName) {
var me = this;
if (fsName === '' || fsName === undefined) {
fsName = 'cephfs';
}
me.url = "/nodes/" + me.nodename + "/ceph/fs/" + fsName;
},
items: [
{
xtype: 'textfield',
fieldLabel: gettext('Name'),
name: 'name',
value: 'cephfs',
listeners: {
change: function(f, value) {
this.up('pveCephCreateFS').setFSName(value);
},
},
submitValue: false, // already encoded in apicall URL
emptyText: 'cephfs',
},
{
xtype: 'proxmoxintegerfield',
fieldLabel: 'Placement Groups',
name: 'pg_num',
value: 128,
emptyText: 128,
minValue: 8,
maxValue: 32768,
allowBlank: false,
},
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Add as Storage'),
value: true,
name: 'add-storage',
autoEl: {
tag: 'div',
'data-qtip': gettext('Add the new CephFS to the cluster storage configuration.'),
},
},
],
initComponent: function() {
var me = this;
if (!me.nodename) {
throw "no node name specified";
}
me.setFSName();
me.callParent();
},
});
Ext.define('PVE.NodeCephFSPanel', {
extend: 'Ext.panel.Panel',
xtype: 'pveNodeCephFSPanel',
mixins: ['Proxmox.Mixin.CBind'],
title: gettext('CephFS'),
onlineHelp: 'pveceph_fs',
border: false,
defaults: {
border: false,
cbind: {
nodename: '{nodename}',
},
},
viewModel: {
parent: null,
data: {
mdsCount: 0,
},
formulas: {
canCreateFS: function(get) {
return get('mdsCount') > 0;
},
},
},
items: [
{
xtype: 'grid',
emptyText: Ext.String.format(gettext('No {0} configured.'), 'CephFS'),
controller: {
xclass: 'Ext.app.ViewController',
init: function(view) {
view.rstore = Ext.create('Proxmox.data.UpdateStore', {
autoLoad: true,
xtype: 'update',
interval: 5 * 1000,
autoStart: true,
storeid: 'pve-ceph-fs',
proxy: {
type: 'proxmox',
url: `/api2/json/nodes/${view.nodename}/ceph/fs`,
},
model: 'pve-ceph-fs',
});
view.setStore(Ext.create('Proxmox.data.DiffStore', {
rstore: view.rstore,
sorters: {
property: 'name',
direction: 'ASC',
},
}));
// manages the "install ceph?" overlay
PVE.Utils.monitor_ceph_installed(view, view.rstore, view.nodename, true);
view.on('destroy', () => view.rstore.stopUpdate());
},
onCreate: function() {
let view = this.getView();
view.rstore.stopUpdate();
Ext.create('PVE.CephCreateFS', {
autoShow: true,
nodename: view.nodename,
listeners: {
destroy: () => view.rstore.startUpdate(),
},
});
},
},
tbar: [
{
text: gettext('Create CephFS'),
reference: 'createButton',
handler: 'onCreate',
bind: {
disabled: '{!canCreateFS}',
},
},
],
columns: [
{
header: gettext('Name'),
flex: 1,
dataIndex: 'name',
},
{
header: gettext('Data Pool'),
flex: 1,
dataIndex: 'data_pool',
},
{
header: gettext('Metadata Pool'),
flex: 1,
dataIndex: 'metadata_pool',
},
],
cbind: {
nodename: '{nodename}',
},
},
{
xtype: 'pveNodeCephMDSList',
title: gettext('Metadata Servers'),
stateId: 'grid-ceph-mds',
type: 'mds',
storeLoadCallback: function(store, records, success) {
var vm = this.getViewModel();
if (!success || !records) {
vm.set('mdsCount', 0);
return;
}
let count = 0;
for (const mds of records) {
if (mds.data.state === 'up:standby') {
count++;
}
}
vm.set('mdsCount', count);
},
cbind: {
nodename: '{nodename}',
},
},
],
}, function() {
Ext.define('pve-ceph-fs', {
extend: 'Ext.data.Model',
fields: ['name', 'data_pool', 'metadata_pool'],
proxy: {
type: 'proxmox',
url: "/api2/json/nodes/localhost/ceph/fs",
},
idProperty: 'name',
});
});
Ext.define('PVE.ceph.Log', {
extend: 'Proxmox.panel.LogView',
xtype: 'cephLogView',
nodename: undefined,
failCallback: function(response) {
var me = this;
var msg = response.htmlStatus;
var windowShow = PVE.Utils.showCephInstallOrMask(me, msg, me.nodename,
function(win) {
me.mon(win, 'cephInstallWindowClosed', function() {
me.loadTask.delay(200);
});
},
);
if (!windowShow) {
Proxmox.Utils.setErrorMask(me, msg);
}
},
});
Ext.define('PVE.node.CephMonMgrList', {
extend: 'Ext.container.Container',
xtype: 'pveNodeCephMonMgr',
mixins: ['Proxmox.Mixin.CBind'],
onlineHelp: 'chapter_pveceph',
defaults: {
border: false,
onlineHelp: 'chapter_pveceph',
flex: 1,
},
layout: {
type: 'vbox',
align: 'stretch',
},
items: [
{
xtype: 'pveNodeCephServiceList',
cbind: { pveSelNode: '{pveSelNode}' },
type: 'mon',
additionalColumns: [
{
header: gettext('Quorum'),
width: 70,
sortable: true,
renderer: Proxmox.Utils.format_boolean,
dataIndex: 'quorum',
},
],
stateId: 'grid-ceph-monitor',
showCephInstallMask: true,
title: gettext('Monitor'),
},
{
xtype: 'pveNodeCephServiceList',
type: 'mgr',
stateId: 'grid-ceph-manager',
cbind: { pveSelNode: '{pveSelNode}' },
title: gettext('Manager'),
},
],
});
Ext.define('PVE.CephCreateOsd', {
extend: 'Proxmox.window.Edit',
xtype: 'pveCephCreateOsd',
subject: 'Ceph OSD',
showProgress: true,
onlineHelp: 'pve_ceph_osds',
initComponent: function() {
let me = this;
if (!me.nodename) {
throw "no node name specified";
}
me.isCreate = true;
Proxmox.Utils.API2Request({
url: `/nodes/${me.nodename}/ceph/crush`,
method: 'GET',
failure: response => Ext.Msg.alert(gettext('Error'), response.htmlStatus),
success: function({ result: { data } }) {
let classes = [...new Set(
Array.from(
data.matchAll(/^device\s[0-9]*\sosd\.[0-9]*\sclass\s(.*)$/gim),
m => m[1],
).filter(v => !['hdd', 'ssd', 'nvme'].includes(v)),
)].map(v => [v, v]);
if (classes.length) {
let kvField = me.down('field[name=crush-device-class]');
kvField.setComboItems([...kvField.comboItems, ...classes]);
}
},
});
Ext.applyIf(me, {
url: "/nodes/" + me.nodename + "/ceph/osd",
method: 'POST',
items: [
{
xtype: 'inputpanel',
onGetValues: function(values) {
Object.keys(values || {}).forEach(function(name) {
if (values[name] === '') {
delete values[name];
}
});
return values;
},
column1: [
{
xtype: 'pmxDiskSelector',
name: 'dev',
nodename: me.nodename,
diskType: 'unused',
includePartitions: true,
fieldLabel: gettext('Disk'),
allowBlank: false,
},
],
column2: [
{
xtype: 'pmxDiskSelector',
name: 'db_dev',
nodename: me.nodename,
diskType: 'journal_disks',
includePartitions: true,
fieldLabel: gettext('DB Disk'),
value: '',
autoSelect: false,
allowBlank: true,
emptyText: gettext('use OSD disk'),
listeners: {
change: function(field, val) {
me.down('field[name=db_dev_size]').setDisabled(!val);
},
},
},
{
xtype: 'numberfield',
name: 'db_dev_size',
fieldLabel: `${gettext('DB size')} (${gettext('GiB')})`,
minValue: 1,
maxValue: 128*1024,
decimalPrecision: 2,
allowBlank: true,
disabled: true,
emptyText: gettext('Automatic'),
},
],
advancedColumn1: [
{
xtype: 'proxmoxcheckbox',
name: 'encrypted',
fieldLabel: gettext('Encrypt OSD'),
},
{
xtype: 'proxmoxKVComboBox',
comboItems: [
['hdd', 'HDD'],
['ssd', 'SSD'],
['nvme', 'NVMe'],
],
name: 'crush-device-class',
nodename: me.nodename,
fieldLabel: gettext('Device Class'),
value: '',
autoSelect: false,
allowBlank: true,
editable: true,
emptyText: gettext('auto detect'),
deleteEmpty: !me.isCreate,
},
],
advancedColumn2: [
{
xtype: 'pmxDiskSelector',
name: 'wal_dev',
nodename: me.nodename,
diskType: 'journal_disks',
includePartitions: true,
fieldLabel: gettext('WAL Disk'),
value: '',
autoSelect: false,
allowBlank: true,
emptyText: gettext('use OSD/DB disk'),
listeners: {
change: function(field, val) {
me.down('field[name=wal_dev_size]').setDisabled(!val);
},
},
},
{
xtype: 'numberfield',
name: 'wal_dev_size',
fieldLabel: `${gettext('WAL size')} (${gettext('GiB')})`,
minValue: 0.5,
maxValue: 128*1024,
decimalPrecision: 2,
allowBlank: true,
disabled: true,
emptyText: gettext('Automatic'),
},
],
},
{
xtype: 'displayfield',
padding: '5 0 0 0',
userCls: 'pmx-hint',
value: 'Note: Ceph is not compatible with disks backed by a hardware ' +
'RAID controller. For details see ' +
'the reference documentation .',
},
],
});
me.callParent();
},
});
Ext.define('PVE.CephRemoveOsd', {
extend: 'Proxmox.window.Edit',
alias: ['widget.pveCephRemoveOsd'],
isRemove: true,
showProgress: true,
method: 'DELETE',
items: [
{
xtype: 'proxmoxcheckbox',
name: 'cleanup',
checked: true,
labelWidth: 130,
fieldLabel: gettext('Cleanup Disks'),
},
{
xtype: 'displayfield',
name: 'osd-flag-hint',
userCls: 'pmx-hint',
value: gettext('Global flags limiting the self healing of Ceph are enabled.'),
hidden: true,
},
{
xtype: 'displayfield',
name: 'degraded-objects-hint',
userCls: 'pmx-hint',
value: gettext('Objects are degraded. Consider waiting until the cluster is healthy.'),
hidden: true,
},
],
initComponent: function() {
let me = this;
if (!me.nodename) {
throw "no node name specified";
}
if (me.osdid === undefined || me.osdid < 0) {
throw "no osdid specified";
}
me.isCreate = true;
me.title = gettext('Destroy') + ': Ceph OSD osd.' + me.osdid.toString();
Ext.applyIf(me, {
url: "/nodes/" + me.nodename + "/ceph/osd/" + me.osdid.toString(),
});
me.callParent();
if (me.warnings.flags) {
me.down('field[name=osd-flag-hint]').setHidden(false);
}
if (me.warnings.degraded) {
me.down('field[name=degraded-objects-hint]').setHidden(false);
}
},
});
Ext.define('PVE.CephSetFlags', {
extend: 'Proxmox.window.Edit',
xtype: 'pveCephSetFlags',
showProgress: true,
width: 720,
layout: 'fit',
onlineHelp: 'pve_ceph_osds',
isCreate: true,
title: Ext.String.format(gettext('Manage {0}'), 'Global OSD Flags'),
submitText: gettext('Apply'),
items: [
{
xtype: 'inputpanel',
onGetValues: function(values) {
let me = this;
let val = {};
me.down('#flaggrid').getStore().each((rec) => {
val[rec.data.name] = rec.data.value ? 1 : 0;
});
return val;
},
items: [
{
xtype: 'grid',
itemId: 'flaggrid',
store: {
listeners: {
update: function() {
this.commitChanges();
},
},
},
columns: [
{
text: gettext('Enable'),
xtype: 'checkcolumn',
width: 75,
dataIndex: 'value',
},
{
text: 'Name',
dataIndex: 'name',
},
{
text: 'Description',
flex: 1,
dataIndex: 'description',
},
],
},
],
},
],
initComponent: function() {
let me = this;
if (!me.nodename) {
throw "no node name specified";
}
Ext.applyIf(me, {
url: "/cluster/ceph/flags",
method: 'PUT',
});
me.callParent();
let grid = me.down('#flaggrid');
me.load({
success: function(response, options) {
let data = response.result.data;
grid.getStore().setData(data);
// re-align after store load, else the window is not centered
me.alignTo(Ext.getBody(), 'c-c');
},
});
},
});
Ext.define('PVE.node.CephOsdTree', {
extend: 'Ext.tree.Panel',
alias: ['widget.pveNodeCephOsdTree'],
onlineHelp: 'chapter_pveceph',
viewModel: {
data: {
nodename: '',
flags: [],
maxversion: '0',
mixedversions: false,
versions: {},
isOsd: false,
downOsd: false,
upOsd: false,
inOsd: false,
outOsd: false,
osdid: '',
osdhost: '',
},
},
controller: {
xclass: 'Ext.app.ViewController',
reload: function() {
let me = this;
let view = me.getView();
let vm = me.getViewModel();
let nodename = vm.get('nodename');
let sm = view.getSelectionModel();
Proxmox.Utils.API2Request({
url: "/nodes/" + nodename + "/ceph/osd",
waitMsgTarget: view,
method: 'GET',
failure: function(response, opts) {
let msg = response.htmlStatus;
PVE.Utils.showCephInstallOrMask(view, msg, nodename, win =>
view.mon(win, 'cephInstallWindowClosed', () => { me.reload(); }),
);
},
success: function(response, opts) {
let data = response.result.data;
let selected = view.getSelection();
let name;
if (selected.length) {
name = selected[0].data.name;
}
data.versions = data.versions || {};
vm.set('versions', data.versions);
// extract max version
let maxversion = "0";
let mixedversions = false;
let traverse;
traverse = function(node, fn) {
fn(node);
if (Array.isArray(node.children)) {
node.children.forEach(c => { traverse(c, fn); });
}
};
traverse(data.root, node => {
// compatibility for old api call
if (node.type === 'host' && !node.version) {
node.version = data.versions[node.name];
}
if (node.version === undefined) {
return;
}
if (PVE.Utils.compare_ceph_versions(node.version, maxversion) !== 0 && maxversion !== "0") {
mixedversions = true;
}
if (PVE.Utils.compare_ceph_versions(node.version, maxversion) > 0) {
maxversion = node.version;
}
});
vm.set('maxversion', maxversion);
vm.set('mixedversions', mixedversions);
sm.deselectAll();
view.setRootNode(data.root);
view.expandAll();
if (name) {
let node = view.getRootNode().findChild('name', name, true);
if (node) {
view.setSelection([node]);
}
}
let flags = data.flags.split(',');
vm.set('flags', flags);
},
});
},
osd_cmd: function(comp) {
let me = this;
let vm = this.getViewModel();
let cmd = comp.cmd;
let params = comp.params || {};
let osdid = vm.get('osdid');
let doRequest = function() {
let targetnode = vm.get('osdhost');
// cmds not node specific and need to work if the OSD node is down
if (['in', 'out'].includes(cmd)) {
targetnode = vm.get('nodename');
}
Proxmox.Utils.API2Request({
url: `/nodes/${targetnode}/ceph/osd/${osdid}/${cmd}`,
waitMsgTarget: me.getView(),
method: 'POST',
params: params,
success: () => { me.reload(); },
failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
},
});
};
if (cmd === 'scrub') {
Ext.MessageBox.defaultButton = params.deep === 1 ? 2 : 1;
Ext.Msg.show({
title: gettext('Confirm'),
icon: params.deep === 1 ? Ext.Msg.WARNING : Ext.Msg.QUESTION,
msg: params.deep !== 1
? Ext.String.format(gettext("Scrub OSD.{0}"), osdid)
: Ext.String.format(gettext("Deep Scrub OSD.{0}"), osdid) +
"',
'osd.{osd}:',
'',
gettext('No OSD selected'),
' ',
],
},
{
text: gettext('Details'),
iconCls: 'fa fa-info-circle',
disabled: true,
bind: {
disabled: '{!isOsd}',
},
handler: 'details',
},
{
text: gettext('Start'),
iconCls: 'fa fa-play',
disabled: true,
bind: {
disabled: '{!downOsd}',
},
cmd: 'start',
handler: 'service_cmd',
},
{
text: gettext('Stop'),
iconCls: 'fa fa-stop',
disabled: true,
bind: {
disabled: '{!upOsd}',
},
cmd: 'stop',
handler: 'service_cmd',
},
{
text: gettext('Restart'),
iconCls: 'fa fa-refresh',
disabled: true,
bind: {
disabled: '{!upOsd}',
},
cmd: 'restart',
handler: 'service_cmd',
},
'-',
{
text: 'Out',
iconCls: 'fa fa-circle-o',
disabled: true,
bind: {
disabled: '{!inOsd}',
},
cmd: 'out',
handler: 'osd_cmd',
},
{
text: 'In',
iconCls: 'fa fa-circle',
disabled: true,
bind: {
disabled: '{!outOsd}',
},
cmd: 'in',
handler: 'osd_cmd',
},
'-',
{
text: gettext('More'),
iconCls: 'fa fa-bars',
disabled: true,
bind: {
disabled: '{!isOsd}',
},
menu: [
{
text: gettext('Scrub'),
iconCls: 'fa fa-shower',
cmd: 'scrub',
handler: 'osd_cmd',
},
{
text: gettext('Deep Scrub'),
iconCls: 'fa fa-bath',
cmd: 'scrub',
params: {
deep: 1,
},
handler: 'osd_cmd',
},
{
text: gettext('Destroy'),
itemId: 'remove',
iconCls: 'fa fa-fw fa-trash-o',
bind: {
disabled: '{!downOsd}',
},
handler: 'destroy_osd',
},
],
},
],
},
fields: [
'name', 'type', 'status', 'host', 'in', 'id',
{ type: 'number', name: 'reweight' },
{ type: 'number', name: 'percent_used' },
{ type: 'integer', name: 'bytes_used' },
{ type: 'integer', name: 'total_space' },
{ type: 'integer', name: 'apply_latency_ms' },
{ type: 'integer', name: 'commit_latency_ms' },
{ type: 'string', name: 'device_class' },
{ type: 'string', name: 'osdtype' },
{ type: 'string', name: 'blfsdev' },
{ type: 'string', name: 'dbdev' },
{ type: 'string', name: 'waldev' },
{
type: 'string', name: 'version', calculate: function(data) {
return PVE.Utils.parse_ceph_version(data);
},
},
{
type: 'string', name: 'iconCls', calculate: function(data) {
let iconMap = {
host: 'fa-building',
osd: 'fa-hdd-o',
root: 'fa-server',
};
return `fa x-fa-tree ${iconMap[data.type] ?? 'fa-folder-o'}`;
},
},
{ type: 'number', name: 'crush_weight' },
],
});
Ext.define('pve-osd-details-devices', {
extend: 'Ext.data.Model',
fields: ['device', 'type', 'physical_device', 'size', 'support_discard', 'dev_node'],
idProperty: 'device',
});
Ext.define('PVE.CephOsdDetails', {
extend: 'Ext.window.Window',
alias: ['widget.pveCephOsdDetails'],
mixins: ['Proxmox.Mixin.CBind'],
cbindData: function() {
let me = this;
me.baseUrl = `/nodes/${me.nodename}/ceph/osd/${me.osdid}`;
return {
title: `${gettext('Details')}: OSD ${me.osdid}`,
};
},
viewModel: {
data: {
device: '',
},
},
modal: true,
width: 650,
minHeight: 250,
resizable: true,
cbind: {
title: '{title}',
},
layout: {
type: 'vbox',
align: 'stretch',
},
defaults: {
layout: 'fit',
border: false,
},
controller: {
xclass: 'Ext.app.ViewController',
reload: function() {
let view = this.getView();
Proxmox.Utils.API2Request({
url: `${view.baseUrl}/metadata`,
waitMsgTarget: view.lookup('detailsTabs'),
method: 'GET',
failure: function(response, opts) {
Proxmox.Utils.setErrorMask(view.lookup('detailsTabs'), response.htmlStatus);
},
success: function(response, opts) {
let d = response.result.data;
let osdData = Object.keys(d.osd).sort().map(x => ({ key: x, value: d.osd[x] }));
view.osdStore.loadData(osdData);
let devices = view.lookup('devices');
let deviceStore = devices.getStore();
deviceStore.loadData(d.devices);
view.lookup('osdGeneral').rstore.fireEvent('load', view.osdStore, osdData, true);
view.lookup('osdNetwork').rstore.fireEvent('load', view.osdStore, osdData, true);
// select 'block' device automatically on first load
if (devices.getSelection().length === 0) {
devices.setSelection(deviceStore.findRecord('device', 'block'));
}
},
});
},
showDevInfo: function(grid, selected) {
let view = this.getView();
if (selected[0]) {
let device = selected[0].data.device;
this.getViewModel().set('device', device);
let detailStore = view.lookup('volumeDetails');
detailStore.rstore.getProxy().setUrl(`api2/json${view.baseUrl}/lv-info`);
detailStore.rstore.getProxy().setExtraParams({ 'type': device });
detailStore.setLoading();
detailStore.rstore.load({ callback: () => detailStore.setLoading(false) });
}
},
init: function() {
this.reload();
},
control: {
'grid[reference=devices]': {
selectionchange: 'showDevInfo',
},
},
},
tbar: [
{
text: gettext('Reload'),
iconCls: 'fa fa-refresh',
handler: 'reload',
},
],
initComponent: function() {
let me = this;
me.osdStore = Ext.create('Proxmox.data.ObjectStore');
Ext.applyIf(me, {
items: [
{
xtype: 'tabpanel',
reference: 'detailsTabs',
items: [
{
xtype: 'proxmoxObjectGrid',
reference: 'osdGeneral',
tooltip: gettext('Various information about the OSD'),
rstore: me.osdStore,
title: gettext('General'),
viewConfig: {
enableTextSelection: true,
},
gridRows: [
{
xtype: 'text',
name: 'version',
text: gettext('Version'),
},
{
xtype: 'text',
name: 'hostname',
text: gettext('Hostname'),
},
{
xtype: 'text',
name: 'osd_data',
text: gettext('OSD data path'),
},
{
xtype: 'text',
name: 'osd_objectstore',
text: gettext('OSD object store'),
},
{
xtype: 'text',
name: 'mem_usage',
text: gettext('Memory usage (PSS)'),
renderer: Proxmox.Utils.render_size,
},
{
xtype: 'text',
name: 'pid',
text: `${gettext('Process ID')} (PID)`,
},
],
},
{
xtype: 'proxmoxObjectGrid',
reference: 'osdNetwork',
tooltip: gettext('Addresses and ports used by the OSD service'),
rstore: me.osdStore,
title: gettext('Network'),
viewConfig: {
enableTextSelection: true,
},
gridRows: [
{
xtype: 'text',
name: 'front_addr',
text: `${gettext('Front Address')}' + mgr.title + ' ';
mgr.statuses.push(gettext('Status') + ': active ');
} else if (mgrmessages[mgr.name] === 'standby') {
mgr.statuses.push(gettext('Status') + ': standby');
} else if (mgr.health > healthstates.HEALTH_WARN) {
mgr.health = healthstates.HEALTH_WARN;
}
return mgr;
},
mds: function(mds) {
if (mdsmessages[mds.name]) {
mds.title = '' + mds.title + ' ';
mds.statuses.push(gettext('Status') + ': ' + mdsmessages[mds.name]+" ");
} else if (mds.addr !== Proxmox.Utils.unknownText) {
mds.statuses.push(gettext('Status') + ': standby');
}
return mds;
},
};
for (let type of ['mon', 'mgr', 'mds']) {
var ids = Object.keys(metadata[type] || {});
me[type] = {};
for (let id of ids) {
const [name, host] = id.split('@');
let result = {
id: id,
health: healthstates.HEALTH_OK,
statuses: [],
messages: [],
name: name,
title: metadata[type][id].name || name,
host: host,
version: PVE.Utils.parse_ceph_version(metadata[type][id]),
service: metadata[type][id].service,
addr: metadata[type][id].addr || metadata[type][id].addrs || Proxmox.Utils.unknownText,
};
result.statuses = [
gettext('Host') + ": " + host,
gettext('Address') + ": " + result.addr,
];
if (checks[type]) {
result = checks[type](result);
}
if (result.service && !result.version) {
result.messages.push(
PVE.Utils.get_ceph_icon_html('HEALTH_UNKNOWN', true) +
gettext('Stopped'),
);
result.health = healthstates.HEALTH_UNKNOWN;
}
if (!result.version && result.addr === Proxmox.Utils.unknownText) {
result.health = healthstates.HEALTH_UNKNOWN;
}
if (result.version) {
result.statuses.push(gettext('Version') + ": " + result.version);
if (PVE.Utils.compare_ceph_versions(result.version, maxversion) !== 0) {
let host_version = metadata.node[host]?.version?.parts || metadata.version?.[host] || "";
if (PVE.Utils.compare_ceph_versions(host_version, maxversion) === 0) {
if (result.health > healthstates.HEALTH_OLD) {
result.health = healthstates.HEALTH_OLD;
}
result.messages.push(
PVE.Utils.get_ceph_icon_html('HEALTH_OLD', true) +
gettext('A newer version was installed but old version still running, please restart'),
);
} else {
if (result.health > healthstates.HEALTH_UPGRADE) {
result.health = healthstates.HEALTH_UPGRADE;
}
result.messages.push(
PVE.Utils.get_ceph_icon_html('HEALTH_UPGRADE', true) +
gettext('Other cluster members use a newer version of this service, please upgrade and restart'),
);
}
}
}
result.statuses.push(''); // empty line
result.text = result.statuses.concat(result.messages).join('{title} ',
},
],
updateAll: function(list) {
var me = this;
me.suspendLayout = true;
list.sort((a, b) => a.id > b.id ? 1 : a.id < b.id ? -1 : 0);
if (!me.ids) {
me.ids = [];
}
let pendingRemoval = {};
me.ids.forEach(id => { pendingRemoval[id] = true; }); // mark all as to-remove first here
for (let i = 0; i < list.length; i++) {
let service = me.getComponent(list[i].id);
if (!service) {
// services and list are sorted, so just insert at i + 1 (first el. is the title)
service = me.insert(i + 1, {
xtype: 'pveCephServiceWidget',
itemId: list[i].id,
});
me.ids.push(list[i].id);
} else {
delete pendingRemoval[list[i].id]; // drop exisiting from for-removal
}
service.updateService(list[i].title, list[i].text, list[i].health);
}
Object.keys(pendingRemoval).forEach(id => me.remove(id)); // GC
me.suspendLayout = false;
me.updateLayout();
},
initComponent: function() {
var me = this;
me.callParent();
me.getComponent('title').update({
title: me.title,
});
},
});
Ext.define('PVE.ceph.ServiceWidget', {
extend: 'Ext.Component',
alias: 'widget.pveCephServiceWidget',
userCls: 'monitor inline-block',
data: {
title: '0',
health: 'HEALTH_ERR',
text: '',
iconCls: PVE.Utils.get_health_icon(),
},
tpl: [
'{title}: ',
'{detail} ',
},
],
},
],
},
{
xtype: 'pveCephStatusDetail',
itemId: 'statusdetail',
plugins: 'responsive',
responsiveConfig: {
'width < 1600': {
columnWidth: 1,
minHeight: 250,
},
'width >= 1600': {
columnWidth: 0.5,
minHeight: 300,
},
},
title: gettext('Status'),
},
{
xtype: 'pveCephServices',
title: gettext('Services'),
itemId: 'services',
plugins: 'responsive',
layout: {
type: 'hbox',
align: 'stretch',
},
responsiveConfig: {
'width < 1600': {
columnWidth: 1,
minHeight: 200,
},
'width >= 1600': {
columnWidth: 0.5,
minHeight: 200,
},
},
},
{
xtype: 'panel',
title: gettext('Performance'),
columnWidth: 1,
bodyPadding: 5,
layout: {
type: 'hbox',
align: 'center',
},
items: [
{
xtype: 'container',
flex: 1,
items: [
{
xtype: 'proxmoxGauge',
itemId: 'space',
title: gettext('Usage'),
},
{
flex: 1,
border: false,
},
{
xtype: 'container',
itemId: 'recovery',
hidden: true,
padding: 25,
items: [
{
xtype: 'pveRunningChart',
itemId: 'recoverychart',
title: gettext('Recovery') +'/ '+ gettext('Rebalance'),
renderer: PVE.Utils.render_bandwidth,
height: 100,
},
{
xtype: 'progressbar',
itemId: 'recoveryprogress',
},
],
},
],
},
{
xtype: 'container',
flex: 2,
defaults: {
padding: 0,
height: 100,
},
items: [
{
xtype: 'pveRunningChart',
itemId: 'reads',
title: gettext('Reads'),
renderer: PVE.Utils.render_bandwidth,
},
{
xtype: 'pveRunningChart',
itemId: 'writes',
title: gettext('Writes'),
renderer: PVE.Utils.render_bandwidth,
},
{
xtype: 'pveRunningChart',
itemId: 'readiops',
title: 'IOPS: ' + gettext('Reads'),
renderer: Ext.util.Format.numberRenderer('0,000'),
},
{
xtype: 'pveRunningChart',
itemId: 'writeiops',
title: 'IOPS: ' + gettext('Writes'),
renderer: Ext.util.Format.numberRenderer('0,000'),
},
],
},
],
},
],
updateAll: function(store, records, success) {
if (!success || records.length === 0) {
return;
}
var me = this;
var rec = records[0];
me.status = rec.data;
// add health panel
me.down('#overallhealth').updateHealth(PVE.Utils.render_ceph_health(rec.data.health || {}));
me.down('#warnings').updateHealth(rec.data.health || {}); // add errors to gridstore
me.getComponent('services').updateAll(me.metadata || {}, rec.data);
me.getComponent('statusdetail').updateAll(me.metadata || {}, rec.data);
// add performance data
let pgmap = rec.data.pgmap;
let used = pgmap.bytes_used;
let total = pgmap.bytes_total;
var text = Ext.String.format(gettext('{0} of {1}'),
Proxmox.Utils.render_size(used),
Proxmox.Utils.render_size(total),
);
// update the usage widget
me.down('#space').updateValue(used/total, text);
let readiops = pgmap.read_op_per_sec;
let writeiops = pgmap.write_op_per_sec;
let reads = pgmap.read_bytes_sec || 0;
let writes = pgmap.write_bytes_sec || 0;
// update the graphs
me.reads.addDataPoint(reads);
me.writes.addDataPoint(writes);
me.readiops.addDataPoint(readiops);
me.writeiops.addDataPoint(writeiops);
let degraded = pgmap.degraded_objects || 0;
let misplaced = pgmap.misplaced_objects || 0;
let unfound = pgmap.unfound_objects || 0;
let unhealthy = degraded + unfound + misplaced;
// update recovery
if (pgmap.recovering_objects_per_sec !== undefined || unhealthy > 0) {
let toRecoverObjects = pgmap.misplaced_total || pgmap.unfound_total || pgmap.degraded_total || 0;
if (toRecoverObjects === 0) {
return; // FIXME: unexpected return and leaves things possible visible when it shouldn't?
}
let recovered = toRecoverObjects - unhealthy || 0;
let speed = pgmap.recovering_bytes_per_sec || 0;
let recoveryRatio = recovered / toRecoverObjects;
let txt = `${(recoveryRatio * 100).toFixed(2)}%`;
if (speed > 0) {
let obj_per_sec = speed / (4 * 1024 * 1024); // 4 MiB per Object
let duration = Proxmox.Utils.format_duration_human(unhealthy/obj_per_sec);
let speedTxt = PVE.Utils.render_bandwidth(speed);
txt += ` (${speedTxt} - ${duration} left)`;
}
me.down('#recovery').setVisible(true);
me.down('#recoveryprogress').updateValue(recoveryRatio);
me.down('#recoveryprogress').updateText(txt);
me.down('#recoverychart').addDataPoint(speed);
} else {
me.down('#recovery').setVisible(false);
me.down('#recoverychart').addDataPoint(0);
}
},
initComponent: function() {
var me = this;
var nodename = me.pveSelNode.data.node;
me.callParent();
var baseurl = '/api2/json' + (nodename ? '/nodes/' + nodename : '/cluster') + '/ceph';
me.store = Ext.create('Proxmox.data.UpdateStore', {
storeid: 'ceph-status-' + (nodename || 'cluster'),
interval: 5000,
proxy: {
type: 'proxmox',
url: baseurl + '/status',
},
});
me.metadatastore = Ext.create('Proxmox.data.UpdateStore', {
storeid: 'ceph-metadata-' + (nodename || 'cluster'),
interval: 15*1000,
proxy: {
type: 'proxmox',
url: '/api2/json/cluster/ceph/metadata',
},
});
// save references for the updatefunction
me.iops = me.down('#iops');
me.readiops = me.down('#readiops');
me.writeiops = me.down('#writeiops');
me.reads = me.down('#reads');
me.writes = me.down('#writes');
// manages the "install ceph?" overlay
PVE.Utils.monitor_ceph_installed(me, me.store, nodename);
me.mon(me.store, 'load', me.updateAll, me);
me.mon(me.metadatastore, 'load', function(store, records, success) {
if (!success || records.length < 1) {
return;
}
me.metadata = records[0].data;
// update services
me.getComponent('services').updateAll(me.metadata, me.status || {});
// update detailstatus panel
me.getComponent('statusdetail').updateAll(me.metadata, me.status || {});
let maxversion = [];
let maxversiontext = "";
for (const [_nodename, data] of Object.entries(me.metadata.node)) {
let version = data.version.parts;
if (PVE.Utils.compare_ceph_versions(version, maxversion) > 0) {
maxversion = version;
maxversiontext = data.version.str;
}
}
me.down('#versioninfo').setValue(maxversiontext);
}, me);
me.on('destroy', me.store.stopUpdate);
me.on('destroy', me.metadatastore.stopUpdate);
me.store.startUpdate();
me.metadatastore.startUpdate();
},
});
Ext.define('PVE.ceph.StatusDetail', {
extend: 'Ext.panel.Panel',
alias: 'widget.pveCephStatusDetail',
layout: {
type: 'hbox',
align: 'stretch',
},
bodyPadding: '0 5',
defaults: {
xtype: 'box',
style: {
'text-align': 'center',
},
},
items: [{
flex: 1,
itemId: 'osds',
maxHeight: 250,
scrollable: true,
padding: '0 10 5 10',
data: {
total: 0,
upin: 0,
upout: 0,
downin: 0,
downout: 0,
oldOSD: [],
ghostOSD: [],
},
tpl: [
'OSDs ',
'',
'',
'{upin} ',
'{upout} ',
' ',
'',
'{downin} ',
'{downout} ',
' ',
'
',
'',
gettext('Total'),
': {total}',
'
',
'',
'
',
'osd.{id}:
',
'{version}
',
' ',
'
',
'',
'',
'`,
'
',
'osd.{id}
',
'
',
' ',
'
',
],
},
{
flex: 1,
border: false,
itemId: 'pgchart',
xtype: 'polar',
height: 184,
innerPadding: 5,
insetPadding: 5,
colors: [
'#CFCFCF',
'#21BF4B',
'#3892d4',
'#FFCC00',
'#FF6C59',
],
store: { },
series: [
{
type: 'pie',
donut: 60,
angleField: 'count',
tooltip: {
trackMouse: true,
renderer: function(tooltip, record, ctx) {
var html = record.get('text');
html += 'PGs ',
'',
'
',
'{count}
',
' ',
],
}],
// similar to mgr dashboard
pgstates: {
// clean
clean: 1,
active: 1,
// busy
activating: 2,
backfill_wait: 2,
backfilling: 2,
creating: 2,
deep: 2,
forced_backfill: 2,
forced_recovery: 2,
peered: 2,
peering: 2,
recovering: 2,
recovery_wait: 2,
remapped: 2,
repair: 2,
scrubbing: 2,
snaptrim: 2,
snaptrim_wait: 2,
// warning
degraded: 3,
undersized: 3,
// critical
backfill_toofull: 4,
backfill_unfound: 4,
down: 4,
incomplete: 4,
inconsistent: 4,
recovery_toofull: 4,
recovery_unfound: 4,
snaptrim_error: 4,
stale: 4,
},
statecategories: [
{
text: gettext('Unknown'),
count: 0,
states: [],
cls: 'faded',
},
{
text: gettext('Clean'),
cls: 'good',
},
{
text: gettext('Busy'),
cls: 'pve-ceph-status-busy',
},
{
text: gettext('Warning'),
cls: 'warning',
},
{
text: gettext('Critical'),
cls: 'critical',
},
],
checkThemeColors: function() {
let me = this;
let rootStyle = getComputedStyle(document.documentElement);
// get color
let background = rootStyle.getPropertyValue("--pwt-panel-background").trim() || "#ffffff";
// set the colors
me.chart.setBackground(background);
me.chart.redraw();
},
updateAll: function(metadata, status) {
let me = this;
me.suspendLayout = true;
let maxversion = "0";
Object.values(metadata.node || {}).forEach(function(node) {
if (PVE.Utils.compare_ceph_versions(node?.version?.parts, maxversion) > 0) {
maxversion = node.version.parts;
}
});
let oldOSD = [], ghostOSD = [];
metadata.osd?.forEach(osd => {
let version = PVE.Utils.parse_ceph_version(osd);
if (version !== undefined) {
if (PVE.Utils.compare_ceph_versions(version, maxversion) !== 0) {
oldOSD.push({
id: osd.id,
version: version,
});
}
} else {
if (Object.keys(osd).length > 1) {
console.warn('got OSD entry with no valid version but other keys', osd);
}
ghostOSD.push({
id: osd.id,
});
}
});
// update PGs sorted
let pgmap = status.pgmap || {};
let pgs_by_state = pgmap.pgs_by_state || [];
pgs_by_state.sort(function(a, b) {
return a.state_name < b.state_name?-1:a.state_name === b.state_name?0:1;
});
me.statecategories.forEach(function(cat) {
cat.count = 0;
cat.states = [];
});
pgs_by_state.forEach(function(state) {
let states = state.state_name.split(/[^a-z]+/);
let result = 0;
for (let i = 0; i < states.length; i++) {
if (me.pgstates[states[i]] > result) {
result = me.pgstates[states[i]];
}
}
// for the list
state.cls = me.statecategories[result].cls;
me.statecategories[result].count += state.count;
me.statecategories[result].states.push(state);
});
me.chart.getStore().setData(me.statecategories);
me.getComponent('pgs').update({ states: pgs_by_state });
let health = status.health || {};
// we collect monitor/osd information from the checks
const downinregex = /(\d+) osds down/;
let downin_osds = 0;
Ext.Object.each(health.checks, function(key, value, obj) {
var found = null;
if (key === 'OSD_DOWN') {
found = value.summary.message.match(downinregex);
if (found !== null) {
downin_osds = parseInt(found[1], 10);
}
}
});
let osdmap = status.osdmap || {};
if (typeof osdmap.osdmap !== "undefined") {
osdmap = osdmap.osdmap;
}
// update OSDs counts
let total_osds = osdmap.num_osds || 0;
let in_osds = osdmap.num_in_osds || 0;
let up_osds = osdmap.num_up_osds || 0;
let down_osds = total_osds - up_osds;
let downout_osds = down_osds - downin_osds;
let upin_osds = in_osds - downin_osds;
let upout_osds = up_osds - upin_osds;
let osds = {
total: total_osds,
upin: upin_osds,
upout: upout_osds,
downin: downin_osds,
downout: downout_osds,
oldOSD: oldOSD,
ghostOSD,
};
let osdcomponent = me.getComponent('osds');
osdcomponent.update(Ext.apply(osdcomponent.data, osds));
me.suspendLayout = false;
me.updateLayout();
},
initComponent: function() {
var me = this;
me.callParent();
me.chart = me.getComponent('pgchart');
me.checkThemeColors();
// switch colors on media query changes
me.mediaQueryList = window.matchMedia("(prefers-color-scheme: dark)");
me.themeListener = (e) => { me.checkThemeColors(); };
me.mediaQueryList.addEventListener("change", me.themeListener);
},
doDestroy: function() {
let me = this;
me.mediaQueryList.removeEventListener("change", me.themeListener);
me.callParent();
},
});
Ext.define('PVE.node.ACMEAccountCreate', {
extend: 'Proxmox.window.Edit',
mixins: ['Proxmox.Mixin.CBind'],
width: 450,
title: gettext('Register Account'),
isCreate: true,
method: 'POST',
submitText: gettext('Register'),
url: '/cluster/acme/account',
showTaskViewer: true,
defaultExists: false,
items: [
{
xtype: 'proxmoxtextfield',
fieldLabel: gettext('Account Name'),
name: 'name',
cbind: {
emptyText: (get) => get('defaultExists') ? '' : 'default',
allowBlank: (get) => !get('defaultExists'),
},
},
{
xtype: 'textfield',
name: 'contact',
vtype: 'email',
allowBlank: false,
fieldLabel: gettext('E-Mail'),
},
{
xtype: 'proxmoxComboGrid',
name: 'directory',
allowBlank: false,
valueField: 'url',
displayField: 'name',
fieldLabel: gettext('ACME Directory'),
store: {
autoLoad: true,
fields: ['name', 'url'],
idProperty: ['name'],
proxy: {
type: 'proxmox',
url: '/api2/json/cluster/acme/directories',
},
sorters: {
property: 'name',
direction: 'ASC',
},
},
listConfig: {
columns: [
{
header: gettext('Name'),
dataIndex: 'name',
flex: 1,
},
{
header: gettext('URL'),
dataIndex: 'url',
flex: 1,
},
],
},
listeners: {
change: function(combogrid, value) {
var me = this;
if (!value) {
return;
}
var disp = me.up('window').down('#tos_url_display');
var field = me.up('window').down('#tos_url');
var checkbox = me.up('window').down('#tos_checkbox');
disp.setValue(gettext('Loading'));
field.setValue(undefined);
checkbox.setValue(undefined);
checkbox.setHidden(true);
Proxmox.Utils.API2Request({
url: '/cluster/acme/meta',
method: 'GET',
params: {
directory: value,
},
success: function(response, opt) {
if (response.result.data.termsOfService) {
field.setValue(response.result.data.termsOfService);
disp.setValue(response.result.data.termsOfService);
checkbox.setHidden(false);
} else {
disp.setValue(undefined);
}
},
failure: function(response, opt) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
},
});
},
},
},
{
xtype: 'displayfield',
itemId: 'tos_url_display',
renderer: PVE.Utils.render_optional_url,
name: 'tos_url_display',
},
{
xtype: 'hidden',
itemId: 'tos_url',
name: 'tos_url',
},
{
xtype: 'proxmoxcheckbox',
itemId: 'tos_checkbox',
boxLabel: gettext('Accept TOS'),
submitValue: false,
validateValue: function(value) {
if (value && this.checked) {
return true;
}
return false;
},
},
],
});
Ext.define('PVE.node.ACMEAccountView', {
extend: 'Proxmox.window.Edit',
width: 600,
fieldDefaults: {
labelWidth: 140,
},
title: gettext('Account'),
items: [
{
xtype: 'displayfield',
fieldLabel: gettext('E-Mail'),
name: 'email',
},
{
xtype: 'displayfield',
fieldLabel: gettext('Created'),
name: 'createdAt',
},
{
xtype: 'displayfield',
fieldLabel: gettext('Status'),
name: 'status',
},
{
xtype: 'displayfield',
fieldLabel: gettext('Directory'),
renderer: PVE.Utils.render_optional_url,
name: 'directory',
},
{
xtype: 'displayfield',
fieldLabel: gettext('Terms of Services'),
renderer: PVE.Utils.render_optional_url,
name: 'tos',
},
],
initComponent: function() {
var me = this;
if (!me.accountname) {
throw "no account name defined";
}
me.url = '/cluster/acme/account/' + me.accountname;
me.callParent();
// hide OK/Reset button, because we just want to show data
me.down('toolbar[dock=bottom]').setVisible(false);
me.load({
success: function(response) {
var data = response.result.data;
data.email = data.account.contact[0];
data.createdAt = data.account.createdAt;
data.status = data.account.status;
me.setValues(data);
},
});
},
});
Ext.define('PVE.node.ACMEDomainEdit', {
extend: 'Proxmox.window.Edit',
alias: 'widget.pveACMEDomainEdit',
subject: gettext('Domain'),
isCreate: false,
width: 450,
onlineHelp: 'sysadmin_certificate_management',
items: [
{
xtype: 'inputpanel',
onGetValues: function(values) {
let me = this;
let win = me.up('pveACMEDomainEdit');
let nodeconfig = win.nodeconfig;
let olddomain = win.domain || {};
let params = {
digest: nodeconfig.digest,
};
let configkey = olddomain.configkey;
let acmeObj = PVE.Parser.parseACME(nodeconfig.acme);
if (values.type === 'dns') {
if (!olddomain.configkey || olddomain.configkey === 'acme') {
// look for first free slot
for (let i = 0; i < PVE.Utils.acmedomain_count; i++) {
if (nodeconfig[`acmedomain${i}`] === undefined) {
configkey = `acmedomain${i}`;
break;
}
}
if (olddomain.domain) {
// we have to remove the domain from the acme domainlist
PVE.Utils.remove_domain_from_acme(acmeObj, olddomain.domain);
params.acme = PVE.Parser.printACME(acmeObj);
}
}
delete values.type;
params[configkey] = PVE.Parser.printPropertyString(values, 'domain');
} else {
if (olddomain.configkey && olddomain.configkey !== 'acme') {
// delete the old dns entry
params.delete = [olddomain.configkey];
}
// add new, remove old and make entries unique
PVE.Utils.add_domain_to_acme(acmeObj, values.domain);
PVE.Utils.remove_domain_from_acme(acmeObj, olddomain.domain);
params.acme = PVE.Parser.printACME(acmeObj);
}
return params;
},
items: [
{
xtype: 'proxmoxKVComboBox',
name: 'type',
fieldLabel: gettext('Challenge Type'),
allowBlank: false,
value: 'standalone',
comboItems: [
['standalone', 'HTTP'],
['dns', 'DNS'],
],
validator: function(value) {
let me = this;
let win = me.up('pveACMEDomainEdit');
let oldconfigkey = win.domain ? win.domain.configkey : undefined;
let val = me.getValue();
if (val === 'dns' && (!oldconfigkey || oldconfigkey === 'acme')) {
// we have to check if there is a 'acmedomain' slot left
let found = false;
for (let i = 0; i < PVE.Utils.acmedomain_count; i++) {
if (!win.nodeconfig[`acmedomain${i}`]) {
found = true;
}
}
if (!found) {
return gettext('Only 5 Domains with type DNS can be configured');
}
}
return true;
},
listeners: {
change: function(cb, value) {
let me = this;
let view = me.up('pveACMEDomainEdit');
let pluginField = view.down('field[name=plugin]');
pluginField.setDisabled(value !== 'dns');
pluginField.setHidden(value !== 'dns');
},
},
},
{
xtype: 'hidden',
name: 'alias',
},
{
xtype: 'pveACMEPluginSelector',
name: 'plugin',
disabled: true,
hidden: true,
allowBlank: false,
},
{
xtype: 'proxmoxtextfield',
name: 'domain',
allowBlank: false,
vtype: 'DnsName',
value: '',
fieldLabel: gettext('Domain'),
},
],
},
],
initComponent: function() {
let me = this;
if (!me.nodename) {
throw 'no nodename given';
}
if (!me.nodeconfig) {
throw 'no nodeconfig given';
}
me.isCreate = !me.domain;
if (me.isCreate) {
me.domain = `${me.nodename}.`; // TODO: FQDN of node
}
me.url = `/api2/extjs/nodes/${me.nodename}/config`;
me.callParent();
if (!me.isCreate) {
me.setValues(me.domain);
} else {
me.setValues({ domain: me.domain });
}
},
});
Ext.define('pve-acme-domains', {
extend: 'Ext.data.Model',
fields: ['domain', 'type', 'alias', 'plugin', 'configkey'],
idProperty: 'domain',
});
Ext.define('PVE.node.ACME', {
extend: 'Ext.grid.Panel',
alias: 'widget.pveACMEView',
margin: '10 0 0 0',
title: 'ACME',
emptyText: gettext('No Domains configured'),
viewModel: {
data: {
domaincount: 0,
account: undefined, // the account we display
configaccount: undefined, // the account set in the config
accountEditable: false,
accountsAvailable: false,
},
formulas: {
canOrder: (get) => !!get('account') && get('domaincount') > 0,
editBtnIcon: (get) => 'fa black fa-' + (get('accountEditable') ? 'check' : 'pencil'),
editBtnText: (get) => get('accountEditable') ? gettext('Apply') : gettext('Edit'),
accountTextHidden: (get) => get('accountEditable') || !get('accountsAvailable'),
accountValueHidden: (get) => !get('accountEditable') || !get('accountsAvailable'),
},
},
controller: {
xclass: 'Ext.app.ViewController',
init: function(view) {
let accountSelector = this.lookup('accountselector');
accountSelector.store.on('load', this.onAccountsLoad, this);
},
onAccountsLoad: function(store, records, success) {
let me = this;
let vm = me.getViewModel();
let configaccount = vm.get('configaccount');
vm.set('accountsAvailable', records.length > 0);
if (me.autoChangeAccount && records.length > 0) {
me.changeAccount(records[0].data.name, () => {
vm.set('accountEditable', false);
me.reload();
});
me.autoChangeAccount = false;
} else if (configaccount) {
if (store.findExact('name', configaccount) !== -1) {
vm.set('account', configaccount);
} else {
vm.set('account', null);
}
}
},
addDomain: function() {
let me = this;
let view = me.getView();
Ext.create('PVE.node.ACMEDomainEdit', {
nodename: view.nodename,
nodeconfig: view.nodeconfig,
apiCallDone: function() {
me.reload();
},
}).show();
},
editDomain: function() {
let me = this;
let view = me.getView();
let selection = view.getSelection();
if (selection.length < 1) return;
Ext.create('PVE.node.ACMEDomainEdit', {
nodename: view.nodename,
nodeconfig: view.nodeconfig,
domain: selection[0].data,
apiCallDone: function() {
me.reload();
},
}).show();
},
removeDomain: function() {
let me = this;
let view = me.getView();
let selection = view.getSelection();
if (selection.length < 1) return;
let rec = selection[0].data;
let params = {};
if (rec.configkey !== 'acme') {
params.delete = rec.configkey;
} else {
let acme = PVE.Parser.parseACME(view.nodeconfig.acme);
PVE.Utils.remove_domain_from_acme(acme, rec.domain);
params.acme = PVE.Parser.printACME(acme);
}
Proxmox.Utils.API2Request({
method: 'PUT',
url: `/nodes/${view.nodename}/config`,
params,
success: function(response, opt) {
me.reload();
},
failure: function(response, opt) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
},
});
},
toggleEditAccount: function() {
let me = this;
let vm = me.getViewModel();
let editable = vm.get('accountEditable');
if (editable) {
me.changeAccount(vm.get('account'), function() {
vm.set('accountEditable', false);
me.reload();
});
} else {
vm.set('accountEditable', true);
}
},
changeAccount: function(account, callback) {
let me = this;
let view = me.getView();
let params = {};
let acme = PVE.Parser.parseACME(view.nodeconfig.acme);
acme.account = account;
params.acme = PVE.Parser.printACME(acme);
Proxmox.Utils.API2Request({
method: 'PUT',
waitMsgTarget: view,
url: `/nodes/${view.nodename}/config`,
params,
success: function(response, opt) {
if (Ext.isFunction(callback)) {
callback();
}
},
failure: function(response, opt) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
},
});
},
order: function() {
let me = this;
let view = me.getView();
Proxmox.Utils.API2Request({
method: 'POST',
params: {
force: 1,
},
url: `/nodes/${view.nodename}/certificates/acme/certificate`,
success: function(response, opt) {
Ext.create('Proxmox.window.TaskViewer', {
upid: response.result.data,
taskDone: function(success) {
me.orderFinished(success);
},
}).show();
},
failure: function(response, opt) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
},
});
},
orderFinished: function(success) {
if (!success) return;
// reload only if the Web UI is open on the same node that the cert was ordered for
if (this.getView().nodename !== Proxmox.NodeName) {
return;
}
var txt = gettext('pveproxy will be restarted with new certificates, please reload the GUI!');
Ext.getBody().mask(txt, ['pve-static-mask']);
// reload after 10 seconds automatically
Ext.defer(function() {
window.location.reload(true);
}, 10000);
},
reload: function() {
let me = this;
let view = me.getView();
view.rstore.load();
},
addAccount: function() {
let me = this;
Ext.create('PVE.node.ACMEAccountCreate', {
autoShow: true,
taskDone: function() {
me.reload();
let accountSelector = me.lookup('accountselector');
me.autoChangeAccount = true;
accountSelector.store.load();
},
});
},
},
tbar: [
{
xtype: 'proxmoxButton',
text: gettext('Add'),
handler: 'addDomain',
selModel: false,
},
{
xtype: 'proxmoxButton',
text: gettext('Edit'),
disabled: true,
handler: 'editDomain',
},
{
xtype: 'proxmoxStdRemoveButton',
handler: 'removeDomain',
},
'-',
{
xtype: 'button',
reference: 'order',
text: gettext('Order Certificates Now'),
bind: {
disabled: '{!canOrder}',
},
handler: 'order',
},
'-',
{
xtype: 'displayfield',
value: gettext('Using Account') + ':',
bind: {
hidden: '{!accountsAvailable}',
},
},
{
xtype: 'displayfield',
reference: 'accounttext',
renderer: (val) => val || Proxmox.Utils.NoneText,
bind: {
value: '{account}',
hidden: '{accountTextHidden}',
},
},
{
xtype: 'pveACMEAccountSelector',
hidden: true,
reference: 'accountselector',
bind: {
value: '{account}',
hidden: '{accountValueHidden}',
},
},
{
xtype: 'button',
iconCls: 'fa black fa-pencil',
bind: {
iconCls: '{editBtnIcon}',
text: '{editBtnText}',
hidden: '{!accountsAvailable}',
},
handler: 'toggleEditAccount',
},
{
xtype: 'displayfield',
value: gettext('No Account available.'),
bind: {
hidden: '{accountsAvailable}',
},
},
{
xtype: 'button',
hidden: true,
reference: 'accountlink',
text: gettext('Add ACME Account'),
bind: {
hidden: '{accountsAvailable}',
},
handler: 'addAccount',
},
],
updateStore: function(store, records, success) {
let me = this;
let data = [];
let rec;
if (success && records.length > 0) {
rec = records[0];
} else {
rec = {
data: {},
};
}
me.nodeconfig = rec.data; // save nodeconfig for updates
let account = 'default';
if (rec.data.acme) {
let obj = PVE.Parser.parseACME(rec.data.acme);
(obj.domains || []).forEach(domain => {
if (domain === '') return;
let record = {
domain,
type: 'standalone',
configkey: 'acme',
};
data.push(record);
});
if (obj.account) {
account = obj.account;
}
}
let vm = me.getViewModel();
let oldaccount = vm.get('account');
// account changed, and we do not edit currently, load again to verify
if (oldaccount !== account && !vm.get('accountEditable')) {
vm.set('configaccount', account);
me.lookup('accountselector').store.load();
}
for (let i = 0; i < PVE.Utils.acmedomain_count; i++) {
let acmedomain = rec.data[`acmedomain${i}`];
if (!acmedomain) continue;
let record = PVE.Parser.parsePropertyString(acmedomain, 'domain');
record.type = 'dns';
record.configkey = `acmedomain${i}`;
data.push(record);
}
vm.set('domaincount', data.length);
me.store.loadData(data, false);
},
listeners: {
itemdblclick: 'editDomain',
},
columns: [
{
dataIndex: 'domain',
flex: 5,
text: gettext('Domain'),
},
{
dataIndex: 'type',
flex: 1,
text: gettext('Type'),
},
{
dataIndex: 'plugin',
flex: 1,
text: gettext('Plugin'),
},
],
initComponent: function() {
var me = this;
if (!me.nodename) {
throw "no nodename given";
}
me.rstore = Ext.create('Proxmox.data.UpdateStore', {
interval: 10 * 1000,
autoStart: true,
storeid: `pve-node-domains-${me.nodename}`,
proxy: {
type: 'proxmox',
url: `/api2/json/nodes/${me.nodename}/config`,
},
});
me.store = Ext.create('Ext.data.Store', {
model: 'pve-acme-domains',
sorters: 'domain',
});
me.callParent();
me.mon(me.rstore, 'load', 'updateStore', me);
Proxmox.Utils.monStoreErrors(me, me.rstore);
me.on('destroy', me.rstore.stopUpdate, me.rstore);
},
});
Ext.define('PVE.node.CertificateView', {
extend: 'Ext.container.Container',
xtype: 'pveCertificatesView',
onlineHelp: 'sysadmin_certificate_management',
mixins: ['Proxmox.Mixin.CBind'],
scrollable: 'y',
items: [
{
xtype: 'pveCertView',
border: 0,
cbind: {
nodename: '{nodename}',
},
},
{
xtype: 'pveACMEView',
border: 0,
cbind: {
nodename: '{nodename}',
},
},
],
});
Ext.define('PVE.node.CertificateViewer', {
extend: 'Proxmox.window.Edit',
title: gettext('Certificate'),
fieldDefaults: {
labelWidth: 120,
},
width: 800,
items: {
xtype: 'inputpanel',
maxHeight: 900,
scrollable: 'y',
columnT: [
{
xtype: 'displayfield',
fieldLabel: gettext('Name'),
name: 'filename',
},
{
xtype: 'displayfield',
fieldLabel: gettext('Fingerprint'),
name: 'fingerprint',
},
{
xtype: 'displayfield',
fieldLabel: gettext('Issuer'),
name: 'issuer',
},
{
xtype: 'displayfield',
fieldLabel: gettext('Subject'),
name: 'subject',
},
],
column1: [
{
xtype: 'displayfield',
fieldLabel: gettext('Public Key Type'),
name: 'public-key-type',
},
{
xtype: 'displayfield',
fieldLabel: gettext('Public Key Size'),
name: 'public-key-bits',
},
],
column2: [
{
xtype: 'displayfield',
fieldLabel: gettext('Valid Since'),
renderer: Proxmox.Utils.render_timestamp,
name: 'notbefore',
},
{
xtype: 'displayfield',
fieldLabel: gettext('Expires'),
renderer: Proxmox.Utils.render_timestamp,
name: 'notafter',
},
],
columnB: [
{
xtype: 'displayfield',
fieldLabel: gettext('Subject Alternative Names'),
name: 'san',
renderer: PVE.Utils.render_san,
},
{
xtype: 'fieldset',
title: gettext('Raw Certificate'),
collapsible: true,
collapsed: true,
items: [{
xtype: 'textarea',
name: 'pem',
editable: false,
grow: true,
growMax: 350,
fieldStyle: {
'white-space': 'pre-wrap',
'font-family': 'monospace',
},
}],
},
],
},
initComponent: function() {
let me = this;
if (!me.cert) {
throw "no cert given";
}
if (!me.nodename) {
throw "no nodename given";
}
me.url = `/nodes/${me.nodename}/certificates/info`;
me.callParent();
// hide OK/Reset button, because we just want to show data
me.down('toolbar[dock=bottom]').setVisible(false);
me.load({
success: function(response) {
if (Ext.isArray(response.result.data)) {
for (const item of response.result.data) {
if (item.filename === me.cert) {
me.setValues(item);
return;
}
}
}
},
});
},
});
Ext.define('PVE.node.CertUpload', {
extend: 'Proxmox.window.Edit',
xtype: 'pveCertUpload',
title: gettext('Upload Custom Certificate'),
resizable: false,
isCreate: true,
submitText: gettext('Upload'),
method: 'POST',
width: 600,
apiCallDone: function(success, response, options) {
if (!success) {
return;
}
let txt = gettext('API server will be restarted to use new certificates, please reload web-interface!');
Ext.getBody().mask(txt, ['pve-static-mask']);
Ext.defer(() => window.location.reload(true), 10000); // reload after 10 seconds automatically
},
items: {
xtype: 'inputpanel',
onGetValues: function(values) {
values.restart = 1;
values.force = 1;
if (!values.key) {
delete values.key;
}
return values;
},
items: [
{
fieldLabel: gettext('Private Key (Optional)'),
labelAlign: 'top',
emptyText: gettext('No change'),
name: 'key',
xtype: 'textarea',
},
{
xtype: 'filebutton',
text: gettext('From File'),
listeners: {
change: function(btn, e, value) {
let form = this.up('form');
for (const file of e.event.target.files) {
PVE.Utils.loadFile(file, res => form.down('field[name=key]').setValue(res));
}
btn.reset();
},
},
},
{
fieldLabel: gettext('Certificate Chain'),
labelAlign: 'top',
allowBlank: false,
name: 'certificates',
xtype: 'textarea',
},
{
xtype: 'filebutton',
text: gettext('From File'),
listeners: {
change: function(btn, e, value) {
let form = this.up('form');
for (const file of e.event.target.files) {
PVE.Utils.loadFile(file, res => form.down('field[name=certificates]').setValue(res));
}
btn.reset();
},
},
},
],
},
initComponent: function() {
let me = this;
if (!me.nodename) {
throw "no nodename given";
}
me.url = `/nodes/${me.nodename}/certificates/custom`;
me.callParent();
},
});
Ext.define('pve-certificate', {
extend: 'Ext.data.Model',
fields: ['filename', 'fingerprint', 'issuer', 'notafter', 'notbefore', 'subject', 'san', 'public-key-bits', 'public-key-type'],
idProperty: 'filename',
});
Ext.define('PVE.node.Certificates', {
extend: 'Ext.grid.Panel',
xtype: 'pveCertView',
tbar: [
{
xtype: 'button',
text: gettext('Upload Custom Certificate'),
handler: function() {
let view = this.up('grid');
Ext.create('PVE.node.CertUpload', {
nodename: view.nodename,
listeners: {
destroy: () => view.reload(),
},
autoShow: true,
});
},
},
{
xtype: 'proxmoxStdRemoveButton',
itemId: 'deletebtn',
text: gettext('Delete Custom Certificate'),
dangerous: true,
selModel: false,
getUrl: function(rec) {
let view = this.up('grid');
return `/nodes/${view.nodename}/certificates/custom?restart=1`;
},
confirmMsg: gettext('Delete custom certificate and switch to generated one?'),
callback: function(options, success, response) {
if (success) {
let txt = gettext('API server will be restarted to use new certificates, please reload web-interface!');
Ext.getBody().mask(txt, ['pve-static-mask']);
// reload after 10 seconds automatically
Ext.defer(() => window.location.reload(true), 10000);
}
},
},
'-',
{
xtype: 'proxmoxButton',
itemId: 'viewbtn',
disabled: true,
text: gettext('View Certificate'),
handler: function() {
this.up('grid').viewCertificate();
},
},
],
columns: [
{
header: gettext('File'),
width: 150,
dataIndex: 'filename',
},
{
header: gettext('Issuer'),
flex: 1,
dataIndex: 'issuer',
},
{
header: gettext('Subject'),
flex: 1,
dataIndex: 'subject',
},
{
header: gettext('Public Key Alogrithm'),
flex: 1,
dataIndex: 'public-key-type',
hidden: true,
},
{
header: gettext('Public Key Size'),
flex: 1,
dataIndex: 'public-key-bits',
hidden: true,
},
{
header: gettext('Valid Since'),
width: 150,
dataIndex: 'notbefore',
renderer: Proxmox.Utils.render_timestamp,
},
{
header: gettext('Expires'),
width: 150,
dataIndex: 'notafter',
renderer: Proxmox.Utils.render_timestamp,
},
{
header: gettext('Subject Alternative Names'),
flex: 1,
dataIndex: 'san',
renderer: PVE.Utils.render_san,
},
{
header: gettext('Fingerprint'),
dataIndex: 'fingerprint',
hidden: true,
},
{
header: gettext('PEM'),
dataIndex: 'pem',
hidden: true,
},
],
reload: function() {
this.rstore.load();
},
viewCertificate: function() {
let me = this;
let selection = me.getSelection();
if (!selection || selection.length < 1) {
return;
}
var win = Ext.create('PVE.node.CertificateViewer', {
cert: selection[0].data.filename,
nodename: me.nodename,
});
win.show();
},
listeners: {
itemdblclick: 'viewCertificate',
},
initComponent: function() {
var me = this;
if (!me.nodename) {
throw "no nodename given";
}
me.rstore = Ext.create('Proxmox.data.UpdateStore', {
storeid: 'certs-' + me.nodename,
model: 'pve-certificate',
proxy: {
type: 'proxmox',
url: '/api2/json/nodes/' + me.nodename + '/certificates/info',
},
});
me.store = {
type: 'diff',
rstore: me.rstore,
};
me.callParent();
me.mon(me.rstore, 'load', store => me.down('#deletebtn').setDisabled(!store.getById('pveproxy-ssl.pem')));
me.rstore.startUpdate();
me.on('destroy', me.rstore.stopUpdate, me.rstore);
},
});
Ext.define('PVE.node.CmdMenu', {
extend: 'Ext.menu.Menu',
xtype: 'nodeCmdMenu',
showSeparator: false,
items: [
{
text: gettext('Create VM'),
itemId: 'createvm',
iconCls: 'fa fa-desktop',
handler: function() {
Ext.create('PVE.qemu.CreateWizard', {
nodename: this.up('menu').nodename,
autoShow: true,
});
},
},
{
text: gettext('Create CT'),
itemId: 'createct',
iconCls: 'fa fa-cube',
handler: function() {
Ext.create('PVE.lxc.CreateWizard', {
nodename: this.up('menu').nodename,
autoShow: true,
});
},
},
{ xtype: 'menuseparator' },
{
text: gettext('Bulk Start'),
itemId: 'bulkstart',
iconCls: 'fa fa-fw fa-play',
handler: function() {
Ext.create('PVE.window.BulkAction', {
nodename: this.up('menu').nodename,
title: gettext('Bulk Start'),
btnText: gettext('Start'),
action: 'startall',
autoShow: true,
});
},
},
{
text: gettext('Bulk Shutdown'),
itemId: 'bulkstop',
iconCls: 'fa fa-fw fa-stop',
handler: function() {
Ext.create('PVE.window.BulkAction', {
nodename: this.up('menu').nodename,
title: gettext('Bulk Shutdown'),
btnText: gettext('Shutdown'),
action: 'stopall',
autoShow: true,
});
},
},
{
text: gettext('Bulk Suspend'),
itemId: 'bulksuspend',
iconCls: 'fa fa-fw fa-download',
handler: function() {
Ext.create('PVE.window.BulkAction', {
nodename: this.up('menu').nodename,
title: gettext('Bulk Suspend'),
btnText: gettext('Suspend'),
action: 'suspendall',
autoShow: true,
});
},
},
{
text: gettext('Bulk Migrate'),
itemId: 'bulkmigrate',
iconCls: 'fa fa-fw fa-send-o',
handler: function() {
Ext.create('PVE.window.BulkAction', {
nodename: this.up('menu').nodename,
title: gettext('Bulk Migrate'),
btnText: gettext('Migrate'),
action: 'migrateall',
autoShow: true,
});
},
},
{ xtype: 'menuseparator' },
{
text: gettext('Shell'),
itemId: 'shell',
iconCls: 'fa fa-fw fa-terminal',
handler: function() {
let nodename = this.up('menu').nodename;
PVE.Utils.openDefaultConsoleWindow(true, 'shell', undefined, nodename, undefined);
},
},
{ xtype: 'menuseparator' },
{
text: gettext('Wake-on-LAN'),
itemId: 'wakeonlan',
iconCls: 'fa fa-fw fa-power-off',
handler: function() {
let nodename = this.up('menu').nodename;
Proxmox.Utils.API2Request({
url: `/nodes/${nodename}/wakeonlan`,
method: 'POST',
failure: (response, opts) => Ext.Msg.alert(gettext('Error'), response.htmlStatus),
success: function(response, opts) {
Ext.Msg.show({
title: 'Success',
icon: Ext.Msg.INFO,
msg: Ext.String.format(
gettext("Wake on LAN packet send for '{0}': '{1}'"),
nodename,
response.result.data,
),
});
},
});
},
},
],
initComponent: function() {
let me = this;
if (!me.nodename) {
throw 'no nodename specified';
}
me.title = gettext('Node') + " '" + me.nodename + "'";
me.callParent();
let caps = Ext.state.Manager.get('GuiCap');
if (!caps.vms['VM.Allocate']) {
me.getComponent('createct').setDisabled(true);
me.getComponent('createvm').setDisabled(true);
}
if (!caps.vms['VM.Migrate']) {
me.getComponent('bulkmigrate').setDisabled(true);
}
if (!caps.vms['VM.PowerMgmt']) {
me.getComponent('bulkstart').setDisabled(true);
me.getComponent('bulkstop').setDisabled(true);
me.getComponent('bulksuspend').setDisabled(true);
}
if (!caps.nodes['Sys.PowerMgmt']) {
me.getComponent('wakeonlan').setDisabled(true);
}
if (!caps.nodes['Sys.Console']) {
me.getComponent('shell').setDisabled(true);
}
if (me.pveSelNode.data.running) {
me.getComponent('wakeonlan').setDisabled(true);
}
if (PVE.Utils.isStandaloneNode()) {
me.getComponent('bulkmigrate').setVisible(false);
}
},
});
Ext.define('PVE.node.Config', {
extend: 'PVE.panel.Config',
alias: 'widget.PVE.node.Config',
onlineHelp: 'chapter_system_administration',
initComponent: function() {
var me = this;
var nodename = me.pveSelNode.data.node;
if (!nodename) {
throw "no node name specified";
}
var caps = Ext.state.Manager.get('GuiCap');
me.statusStore = Ext.create('Proxmox.data.ObjectStore', {
url: "/api2/json/nodes/" + nodename + "/status",
interval: 5000,
});
var node_command = function(cmd) {
Proxmox.Utils.API2Request({
params: { command: cmd },
url: '/nodes/' + nodename + '/status',
method: 'POST',
waitMsgTarget: me,
failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
},
});
};
var actionBtn = Ext.create('Ext.Button', {
text: gettext('Bulk Actions'),
iconCls: 'fa fa-fw fa-ellipsis-v',
disabled: !caps.vms['VM.PowerMgmt'] && !caps.vms['VM.Migrate'],
menu: new Ext.menu.Menu({
items: [
{
text: gettext('Bulk Start'),
iconCls: 'fa fa-fw fa-play',
disabled: !caps.vms['VM.PowerMgmt'],
handler: function() {
Ext.create('PVE.window.BulkAction', {
autoShow: true,
nodename: nodename,
title: gettext('Bulk Start'),
btnText: gettext('Start'),
action: 'startall',
});
},
},
{
text: gettext('Bulk Shutdown'),
iconCls: 'fa fa-fw fa-stop',
disabled: !caps.vms['VM.PowerMgmt'],
handler: function() {
Ext.create('PVE.window.BulkAction', {
autoShow: true,
nodename: nodename,
title: gettext('Bulk Shutdown'),
btnText: gettext('Shutdown'),
action: 'stopall',
});
},
},
{
text: gettext('Bulk Suspend'),
iconCls: 'fa fa-fw fa-download',
disabled: !caps.vms['VM.PowerMgmt'],
handler: function() {
Ext.create('PVE.window.BulkAction', {
autoShow: true,
nodename: nodename,
title: gettext('Bulk Suspend'),
btnText: gettext('Suspend'),
action: 'suspendall',
});
},
},
{
text: gettext('Bulk Migrate'),
iconCls: 'fa fa-fw fa-send-o',
disabled: !caps.vms['VM.Migrate'],
hidden: PVE.Utils.isStandaloneNode(),
handler: function() {
Ext.create('PVE.window.BulkAction', {
autoShow: true,
nodename: nodename,
title: gettext('Bulk Migrate'),
btnText: gettext('Migrate'),
action: 'migrateall',
});
},
},
],
}),
});
let restartBtn = Ext.create('Proxmox.button.Button', {
text: gettext('Reboot'),
disabled: !caps.nodes['Sys.PowerMgmt'],
dangerous: true,
confirmMsg: Ext.String.format(gettext("Reboot node '{0}'?"), nodename),
handler: function() {
node_command('reboot');
},
iconCls: 'fa fa-undo',
});
var shutdownBtn = Ext.create('Proxmox.button.Button', {
text: gettext('Shutdown'),
disabled: !caps.nodes['Sys.PowerMgmt'],
dangerous: true,
confirmMsg: Ext.String.format(gettext("Shutdown node '{0}'?"), nodename),
handler: function() {
node_command('shutdown');
},
iconCls: 'fa fa-power-off',
});
var shellBtn = Ext.create('PVE.button.ConsoleButton', {
disabled: !caps.nodes['Sys.Console'],
text: gettext('Shell'),
consoleType: 'shell',
nodename: nodename,
});
me.items = [];
Ext.apply(me, {
title: gettext('Node') + " '" + nodename + "'",
hstateid: 'nodetab',
defaults: {
statusStore: me.statusStore,
},
tbar: [restartBtn, shutdownBtn, shellBtn, actionBtn],
});
if (caps.nodes['Sys.Audit']) {
me.items.push(
{
xtype: 'pveNodeSummary',
title: gettext('Summary'),
iconCls: 'fa fa-book',
itemId: 'summary',
},
{
xtype: 'pmxNotesView',
title: gettext('Notes'),
iconCls: 'fa fa-sticky-note-o',
itemId: 'notes',
},
);
}
if (caps.nodes['Sys.Console']) {
me.items.push(
{
xtype: 'pveNoVncConsole',
title: gettext('Shell'),
iconCls: 'fa fa-terminal',
itemId: 'jsconsole',
consoleType: 'shell',
xtermjs: true,
nodename: nodename,
},
);
}
if (caps.nodes['Sys.Audit']) {
me.items.push(
{
xtype: 'proxmoxNodeServiceView',
title: gettext('System'),
iconCls: 'fa fa-cogs',
itemId: 'services',
expandedOnInit: true,
restartCommand: 'reload', // avoid disruptions
startOnlyServices: {
'pveproxy': true,
'pvedaemon': true,
'pve-cluster': true,
},
nodename: nodename,
onlineHelp: 'pve_service_daemons',
},
{
xtype: 'proxmoxNodeNetworkView',
title: gettext('Network'),
iconCls: 'fa fa-exchange',
itemId: 'network',
showApplyBtn: true,
groups: ['services'],
nodename: nodename,
onlineHelp: 'sysadmin_network_configuration',
},
{
xtype: 'pveCertificatesView',
title: gettext('Certificates'),
iconCls: 'fa fa-certificate',
itemId: 'certificates',
groups: ['services'],
nodename: nodename,
},
{
xtype: 'proxmoxNodeDNSView',
title: gettext('DNS'),
iconCls: 'fa fa-globe',
groups: ['services'],
itemId: 'dns',
nodename: nodename,
onlineHelp: 'sysadmin_network_configuration',
},
{
xtype: 'proxmoxNodeHostsView',
title: gettext('Hosts'),
iconCls: 'fa fa-globe',
groups: ['services'],
itemId: 'hosts',
nodename: nodename,
onlineHelp: 'sysadmin_network_configuration',
},
{
xtype: 'proxmoxNodeOptionsView',
title: gettext('Options'),
iconCls: 'fa fa-gear',
groups: ['services'],
itemId: 'options',
nodename: nodename,
onlineHelp: 'proxmox_node_management',
},
{
xtype: 'proxmoxNodeTimeView',
title: gettext('Time'),
itemId: 'time',
groups: ['services'],
nodename: nodename,
iconCls: 'fa fa-clock-o',
});
}
if (caps.nodes['Sys.Syslog']) {
me.items.push({
xtype: 'proxmoxJournalView',
title: 'Syslog',
iconCls: 'fa fa-list',
groups: ['services'],
disabled: !caps.nodes['Sys.Syslog'],
itemId: 'syslog',
url: "/api2/extjs/nodes/" + nodename + "/journal",
});
if (caps.nodes['Sys.Modify']) {
me.items.push({
xtype: 'proxmoxNodeAPT',
title: gettext('Updates'),
iconCls: 'fa fa-refresh',
expandedOnInit: true,
disabled: !caps.nodes['Sys.Console'],
// do we want to link to system updates instead?
itemId: 'apt',
upgradeBtn: {
xtype: 'pveConsoleButton',
disabled: Proxmox.UserName !== 'root@pam',
text: gettext('Upgrade'),
consoleType: 'upgrade',
nodename: nodename,
},
nodename: nodename,
});
me.items.push({
xtype: 'proxmoxNodeAPTRepositories',
title: gettext('Repositories'),
iconCls: 'fa fa-files-o',
itemId: 'aptrepositories',
nodename: nodename,
onlineHelp: 'sysadmin_package_repositories',
groups: ['apt'],
});
}
}
if (caps.nodes['Sys.Audit']) {
me.items.push(
{
xtype: 'pveFirewallRules',
iconCls: 'fa fa-shield',
title: gettext('Firewall'),
allow_iface: true,
base_url: '/nodes/' + nodename + '/firewall/rules',
list_refs_url: '/cluster/firewall/refs',
itemId: 'firewall',
},
{
xtype: 'pveFirewallOptions',
title: gettext('Options'),
iconCls: 'fa fa-gear',
onlineHelp: 'pve_firewall_host_specific_configuration',
groups: ['firewall'],
base_url: '/nodes/' + nodename + '/firewall/options',
fwtype: 'node',
itemId: 'firewall-options',
});
}
if (caps.nodes['Sys.Audit']) {
me.items.push(
{
xtype: 'pmxDiskList',
title: gettext('Disks'),
itemId: 'storage',
expandedOnInit: true,
iconCls: 'fa fa-hdd-o',
nodename: nodename,
includePartitions: true,
supportsWipeDisk: true,
},
{
xtype: 'pveLVMList',
title: 'LVM',
itemId: 'lvm',
onlineHelp: 'chapter_lvm',
iconCls: 'fa fa-square',
groups: ['storage'],
},
{
xtype: 'pveLVMThinList',
title: 'LVM-Thin',
itemId: 'lvmthin',
onlineHelp: 'chapter_lvm',
iconCls: 'fa fa-square-o',
groups: ['storage'],
},
{
xtype: 'pveDirectoryList',
title: Proxmox.Utils.directoryText,
itemId: 'directory',
onlineHelp: 'chapter_storage',
iconCls: 'fa fa-folder',
groups: ['storage'],
},
{
title: 'ZFS',
itemId: 'zfs',
onlineHelp: 'chapter_zfs',
iconCls: 'fa fa-th-large',
groups: ['storage'],
xtype: 'pveZFSList',
},
{
xtype: 'pveNodeCephStatus',
title: 'Ceph',
itemId: 'ceph',
iconCls: 'fa fa-ceph',
},
{
xtype: 'pveNodeCephConfigCrush',
title: gettext('Configuration'),
iconCls: 'fa fa-gear',
groups: ['ceph'],
itemId: 'ceph-config',
},
{
xtype: 'pveNodeCephMonMgr',
title: gettext('Monitor'),
iconCls: 'fa fa-tv',
groups: ['ceph'],
itemId: 'ceph-monlist',
},
{
xtype: 'pveNodeCephOsdTree',
title: 'OSD',
iconCls: 'fa fa-hdd-o',
groups: ['ceph'],
itemId: 'ceph-osdtree',
},
{
xtype: 'pveNodeCephFSPanel',
title: 'CephFS',
iconCls: 'fa fa-folder',
groups: ['ceph'],
nodename: nodename,
itemId: 'ceph-cephfspanel',
},
{
xtype: 'pveNodeCephPoolList',
title: gettext('Pools'),
iconCls: 'fa fa-sitemap',
groups: ['ceph'],
itemId: 'ceph-pools',
},
{
xtype: 'pveReplicaView',
iconCls: 'fa fa-retweet',
title: gettext('Replication'),
itemId: 'replication',
},
);
}
if (caps.nodes['Sys.Syslog']) {
me.items.push(
{
xtype: 'proxmoxLogView',
title: gettext('Log'),
iconCls: 'fa fa-list',
groups: ['firewall'],
onlineHelp: 'chapter_pve_firewall',
url: '/api2/extjs/nodes/' + nodename + '/firewall/log',
itemId: 'firewall-fwlog',
log_select_timespan: true,
submitFormat: 'U',
},
{
xtype: 'cephLogView',
title: gettext('Log'),
itemId: 'ceph-log',
iconCls: 'fa fa-list',
groups: ['ceph'],
onlineHelp: 'chapter_pveceph',
url: "/api2/extjs/nodes/" + nodename + "/ceph/log",
nodename: nodename,
});
}
me.items.push(
{
title: gettext('Task History'),
iconCls: 'fa fa-list-alt',
itemId: 'tasks',
nodename: nodename,
xtype: 'proxmoxNodeTasks',
extraFilter: [
{
xtype: 'pveGuestIDSelector',
fieldLabel: 'VMID',
allowBlank: true,
name: 'vmid',
},
],
},
{
title: gettext('Subscription'),
iconCls: 'fa fa-support',
itemId: 'support',
xtype: 'pveNodeSubscription',
nodename: nodename,
},
);
me.callParent();
me.mon(me.statusStore, 'load', function(store, records, success) {
let uptimerec = store.data.get('uptime');
let powermgmt = caps.nodes['Sys.PowerMgmt'] && uptimerec && uptimerec.data.value;
restartBtn.setDisabled(!powermgmt);
shutdownBtn.setDisabled(!powermgmt);
shellBtn.setDisabled(!powermgmt);
});
me.on('afterrender', function() {
me.statusStore.startUpdate();
});
me.on('destroy', function() {
me.statusStore.stopUpdate();
});
},
});
Ext.define('PVE.node.CreateDirectory', {
extend: 'Proxmox.window.Edit',
xtype: 'pveCreateDirectory',
subject: Proxmox.Utils.directoryText,
showProgress: true,
onlineHelp: 'chapter_storage',
initComponent: function() {
var me = this;
if (!me.nodename) {
throw "no node name specified";
}
me.isCreate = true;
Ext.applyIf(me, {
url: "/nodes/" + me.nodename + "/disks/directory",
method: 'POST',
items: [
{
xtype: 'pmxDiskSelector',
name: 'device',
nodename: me.nodename,
diskType: 'unused',
includePartitions: true,
fieldLabel: gettext('Disk'),
allowBlank: false,
},
{
xtype: 'proxmoxKVComboBox',
comboItems: [
['ext4', 'ext4'],
['xfs', 'xfs'],
],
fieldLabel: gettext('Filesystem'),
name: 'filesystem',
value: '',
allowBlank: false,
},
{
xtype: 'proxmoxtextfield',
name: 'name',
fieldLabel: gettext('Name'),
allowBlank: false,
},
{
xtype: 'proxmoxcheckbox',
name: 'add_storage',
fieldLabel: gettext('Add Storage'),
value: '1',
},
],
});
me.callParent();
},
});
Ext.define('PVE.node.Directorylist', {
extend: 'Ext.grid.Panel',
xtype: 'pveDirectoryList',
viewModel: {
data: {
path: '',
},
formulas: {
dirName: (get) => get('path')?.replace('/mnt/pve/', '') || undefined,
},
},
controller: {
xclass: 'Ext.app.ViewController',
destroyDirectory: function() {
let me = this;
let vm = me.getViewModel();
let view = me.getView();
const dirName = vm.get('dirName');
if (!view.nodename) {
throw "no node name specified";
}
if (!dirName) {
throw "no directory name specified";
}
Ext.create('PVE.window.SafeDestroyStorage', {
url: `/nodes/${view.nodename}/disks/directory/${dirName}`,
item: { id: dirName },
taskName: 'dirremove',
taskDone: () => { view.reload(); },
}).show();
},
},
stateful: true,
stateId: 'grid-node-directory',
columns: [
{
text: gettext('Path'),
dataIndex: 'path',
flex: 1,
},
{
header: gettext('Device'),
flex: 1,
dataIndex: 'device',
},
{
header: gettext('Type'),
width: 100,
dataIndex: 'type',
},
{
header: gettext('Options'),
width: 100,
dataIndex: 'options',
},
{
header: gettext('Unit File'),
hidden: true,
dataIndex: 'unitfile',
},
],
rootVisible: false,
useArrows: true,
tbar: [
{
text: gettext('Reload'),
iconCls: 'fa fa-refresh',
handler: function() {
this.up('panel').reload();
},
},
{
text: `${gettext('Create')}: ${gettext('Directory')}`,
handler: function() {
let view = this.up('panel');
Ext.create('PVE.node.CreateDirectory', {
nodename: view.nodename,
listeners: {
destroy: () => view.reload(),
},
autoShow: true,
});
},
},
'->',
{
xtype: 'tbtext',
data: {
dirName: undefined,
},
bind: {
data: {
dirName: "{dirName}",
},
},
tpl: [
'',
gettext('Directory') + ' {dirName}:',
'',
Ext.String.format(gettext('No {0} selected'), gettext('directory')),
' ',
],
},
{
text: gettext('More'),
iconCls: 'fa fa-bars',
disabled: true,
bind: {
disabled: '{!dirName}',
},
menu: [
{
text: gettext('Destroy'),
itemId: 'remove',
iconCls: 'fa fa-fw fa-trash-o',
handler: 'destroyDirectory',
disabled: true,
bind: {
disabled: '{!dirName}',
},
},
],
},
],
reload: function() {
let me = this;
me.store.load();
me.store.sort();
},
listeners: {
activate: function() {
this.reload();
},
selectionchange: function(model, selected) {
let me = this;
let vm = me.getViewModel();
vm.set('path', selected[0]?.data.path || '');
},
},
initComponent: function() {
let me = this;
me.nodename = me.pveSelNode.data.node;
if (!me.nodename) {
throw "no node name specified";
}
Ext.apply(me, {
store: {
fields: ['path', 'device', 'type', 'options', 'unitfile'],
proxy: {
type: 'proxmox',
url: `/api2/json/nodes/${me.nodename}/disks/directory`,
},
sorters: 'path',
},
});
me.callParent();
Proxmox.Utils.monStoreErrors(me, me.getStore(), true);
me.reload();
},
});
Ext.define('PVE.node.CreateLVM', {
extend: 'Proxmox.window.Edit',
xtype: 'pveCreateLVM',
onlineHelp: 'chapter_lvm',
subject: 'LVM Volume Group',
showProgress: true,
isCreate: true,
initComponent: function() {
let me = this;
if (!me.nodename) {
throw "no node name specified";
}
me.isCreate = true;
Ext.applyIf(me, {
url: `/nodes/${me.nodename}/disks/lvm`,
method: 'POST',
items: [
{
xtype: 'pmxDiskSelector',
name: 'device',
nodename: me.nodename,
diskType: 'unused',
includePartitions: true,
fieldLabel: gettext('Disk'),
allowBlank: false,
},
{
xtype: 'proxmoxtextfield',
name: 'name',
fieldLabel: gettext('Name'),
allowBlank: false,
},
{
xtype: 'proxmoxcheckbox',
name: 'add_storage',
fieldLabel: gettext('Add Storage'),
value: '1',
},
],
});
me.callParent();
},
});
Ext.define('PVE.node.LVMList', {
extend: 'Ext.tree.Panel',
xtype: 'pveLVMList',
viewModel: {
data: {
volumeGroup: '',
},
},
controller: {
xclass: 'Ext.app.ViewController',
destroyVolumeGroup: function() {
let me = this;
let vm = me.getViewModel();
let view = me.getView();
const volumeGroup = vm.get('volumeGroup');
if (!view.nodename) {
throw "no node name specified";
}
if (!volumeGroup) {
throw "no volume group specified";
}
Ext.create('PVE.window.SafeDestroyStorage', {
url: `/nodes/${view.nodename}/disks/lvm/${volumeGroup}`,
item: { id: volumeGroup },
taskName: 'lvmremove',
taskDone: () => { view.reload(); },
}).show();
},
},
emptyText: PVE.Utils.renderNotFound('VGs'),
stateful: true,
stateId: 'grid-node-lvm',
rootVisible: false,
useArrows: true,
columns: [
{
xtype: 'treecolumn',
text: gettext('Name'),
dataIndex: 'name',
flex: 1,
},
{
text: gettext('Number of LVs'),
dataIndex: 'lvcount',
width: 150,
align: 'right',
},
{
header: gettext('Assigned to LVs'),
width: 130,
dataIndex: 'usage',
tdCls: 'x-progressbar-default-cell',
xtype: 'widgetcolumn',
widget: {
xtype: 'pveProgressBar',
},
},
{
header: gettext('Size'),
width: 100,
align: 'right',
sortable: true,
renderer: Proxmox.Utils.format_size,
dataIndex: 'size',
},
{
header: gettext('Free'),
width: 100,
align: 'right',
sortable: true,
renderer: Proxmox.Utils.format_size,
dataIndex: 'free',
},
],
tbar: [
{
text: gettext('Reload'),
iconCls: 'fa fa-refresh',
handler: function() {
this.up('panel').reload();
},
},
{
text: gettext('Create') + ': Volume Group',
handler: function() {
let view = this.up('panel');
Ext.create('PVE.node.CreateLVM', {
nodename: view.nodename,
taskDone: () => view.reload(),
autoShow: true,
});
},
},
'->',
{
xtype: 'tbtext',
data: {
volumeGroup: undefined,
},
bind: {
data: {
volumeGroup: "{volumeGroup}",
},
},
tpl: [
'',
'Volume group {volumeGroup}:',
'',
Ext.String.format(gettext('No {0} selected'), 'volume group'),
' ',
],
},
{
text: gettext('More'),
iconCls: 'fa fa-bars',
disabled: true,
bind: {
disabled: '{!volumeGroup}',
},
menu: [
{
text: gettext('Destroy'),
itemId: 'remove',
iconCls: 'fa fa-fw fa-trash-o',
handler: 'destroyVolumeGroup',
disabled: true,
bind: {
disabled: '{!volumeGroup}',
},
},
],
},
],
reload: function() {
let me = this;
let sm = me.getSelectionModel();
Proxmox.Utils.API2Request({
url: `/nodes/${me.nodename}/disks/lvm`,
waitMsgTarget: me,
method: 'GET',
failure: (response, opts) => Proxmox.Utils.setErrorMask(me, response.htmlStatus),
success: function(response, opts) {
sm.deselectAll();
me.setRootNode(response.result.data);
me.expandAll();
},
});
},
listeners: {
activate: function() {
this.reload();
},
selectionchange: function(model, selected) {
let me = this;
let vm = me.getViewModel();
if (selected.length < 1 || selected[0].data.parentId !== 'root') {
vm.set('volumeGroup', '');
} else {
vm.set('volumeGroup', selected[0].data.name);
}
},
},
selModel: 'treemodel',
fields: [
'name',
'size',
'free',
{
type: 'string',
name: 'iconCls',
calculate: data => `fa x-fa-tree fa-${data.leaf ? 'hdd-o' : 'object-group'}`,
},
{
type: 'number',
name: 'usage',
calculate: data => (data.size - data.free) / data.size,
},
],
sorters: 'name',
initComponent: function() {
let me = this;
me.nodename = me.pveSelNode.data.node;
if (!me.nodename) {
throw "no node name specified";
}
me.callParent();
me.reload();
},
});
Ext.define('PVE.node.CreateLVMThin', {
extend: 'Proxmox.window.Edit',
xtype: 'pveCreateLVMThin',
onlineHelp: 'chapter_lvm',
subject: 'LVM Thinpool',
showProgress: true,
isCreate: true,
initComponent: function() {
let me = this;
if (!me.nodename) {
throw "no node name specified";
}
Ext.applyIf(me, {
url: `/nodes/${me.nodename}/disks/lvmthin`,
method: 'POST',
items: [
{
xtype: 'pmxDiskSelector',
name: 'device',
nodename: me.nodename,
diskType: 'unused',
includePartitions: true,
fieldLabel: gettext('Disk'),
allowBlank: false,
},
{
xtype: 'proxmoxtextfield',
name: 'name',
fieldLabel: gettext('Name'),
allowBlank: false,
},
{
xtype: 'proxmoxcheckbox',
name: 'add_storage',
fieldLabel: gettext('Add Storage'),
value: '1',
},
],
});
me.callParent();
},
});
Ext.define('PVE.node.LVMThinList', {
extend: 'Ext.grid.Panel',
xtype: 'pveLVMThinList',
viewModel: {
data: {
thinPool: '',
volumeGroup: '',
},
},
controller: {
xclass: 'Ext.app.ViewController',
destroyThinPool: function() {
let me = this;
let vm = me.getViewModel();
let view = me.getView();
const thinPool = vm.get('thinPool');
const volumeGroup = vm.get('volumeGroup');
if (!view.nodename) {
throw "no node name specified";
}
if (!thinPool) {
throw "no thin pool specified";
}
if (!volumeGroup) {
throw "no volume group specified";
}
Ext.create('PVE.window.SafeDestroyStorage', {
url: `/nodes/${view.nodename}/disks/lvmthin/${thinPool}`,
params: { 'volume-group': volumeGroup },
item: { id: `${volumeGroup}/${thinPool}` },
taskName: 'lvmthinremove',
taskDone: () => { view.reload(); },
}).show();
},
},
emptyText: PVE.Utils.renderNotFound('Thin-Pool'),
stateful: true,
stateId: 'grid-node-lvmthin',
rootVisible: false,
useArrows: true,
columns: [
{
text: gettext('Name'),
dataIndex: 'lv',
flex: 1,
},
{
header: 'Volume Group',
width: 110,
dataIndex: 'vg',
},
{
header: gettext('Usage'),
width: 110,
dataIndex: 'usage',
tdCls: 'x-progressbar-default-cell',
xtype: 'widgetcolumn',
widget: {
xtype: 'pveProgressBar',
},
},
{
header: gettext('Size'),
width: 100,
align: 'right',
sortable: true,
renderer: Proxmox.Utils.format_size,
dataIndex: 'lv_size',
},
{
header: gettext('Used'),
width: 100,
align: 'right',
sortable: true,
renderer: Proxmox.Utils.format_size,
dataIndex: 'used',
},
{
header: gettext('Metadata Usage'),
width: 120,
dataIndex: 'metadata_usage',
tdCls: 'x-progressbar-default-cell',
xtype: 'widgetcolumn',
widget: {
xtype: 'pveProgressBar',
},
},
{
header: gettext('Metadata Size'),
width: 120,
align: 'right',
sortable: true,
renderer: Proxmox.Utils.format_size,
dataIndex: 'metadata_size',
},
{
header: gettext('Metadata Used'),
width: 125,
align: 'right',
sortable: true,
renderer: Proxmox.Utils.format_size,
dataIndex: 'metadata_used',
},
],
tbar: [
{
text: gettext('Reload'),
iconCls: 'fa fa-refresh',
handler: function() {
this.up('panel').reload();
},
},
{
text: gettext('Create') + ': Thinpool',
handler: function() {
var view = this.up('panel');
Ext.create('PVE.node.CreateLVMThin', {
nodename: view.nodename,
taskDone: () => view.reload(),
autoShow: true,
});
},
},
'->',
{
xtype: 'tbtext',
data: {
thinPool: undefined,
volumeGroup: undefined,
},
bind: {
data: {
thinPool: "{thinPool}",
volumeGroup: "{volumeGroup}",
},
},
tpl: [
'',
'',
'Thinpool {volumeGroup}/{thinPool}:',
'', // volumeGroup
'Missing volume group (node running old version?)',
' ',
'', // thinPool
Ext.String.format(gettext('No {0} selected'), 'thinpool'),
' ',
],
},
{
text: gettext('More'),
iconCls: 'fa fa-bars',
disabled: true,
bind: {
disabled: '{!volumeGroup || !thinPool}',
},
menu: [
{
text: gettext('Destroy'),
itemId: 'remove',
iconCls: 'fa fa-fw fa-trash-o',
handler: 'destroyThinPool',
disabled: true,
bind: {
disabled: '{!volumeGroup || !thinPool}',
},
},
],
},
],
reload: function() {
let me = this;
me.store.load();
me.store.sort();
},
listeners: {
activate: function() {
this.reload();
},
selectionchange: function(model, selected) {
let me = this;
let vm = me.getViewModel();
vm.set('volumeGroup', selected[0]?.data.vg || '');
vm.set('thinPool', selected[0]?.data.lv || '');
},
},
initComponent: function() {
let me = this;
me.nodename = me.pveSelNode.data.node;
if (!me.nodename) {
throw "no node name specified";
}
Ext.apply(me, {
store: {
fields: [
'lv',
'lv_size',
'used',
'metadata_size',
'metadata_used',
{
type: 'number',
name: 'usage',
calculate: data => data.used / data.lv_size,
},
{
type: 'number',
name: 'metadata_usage',
calculate: data => data.metadata_used / data.metadata_size,
},
],
proxy: {
type: 'proxmox',
url: `/api2/json/nodes/${me.nodename}/disks/lvmthin`,
},
sorters: 'lv',
},
});
me.callParent();
Proxmox.Utils.monStoreErrors(me, me.getStore(), true);
me.reload();
},
});
Ext.define('PVE.node.StatusView', {
extend: 'Proxmox.panel.StatusView',
alias: 'widget.pveNodeStatus',
height: 350,
bodyPadding: '15 5 15 5',
layout: {
type: 'table',
columns: 2,
tableAttrs: {
style: {
width: '100%',
},
},
},
defaults: {
xtype: 'pmxInfoWidget',
padding: '0 10 5 10',
},
items: [
{
itemId: 'cpu',
iconCls: 'fa fa-fw pmx-itype-icon-processor pmx-icon',
title: gettext('CPU usage'),
valueField: 'cpu',
maxField: 'cpuinfo',
renderer: Proxmox.Utils.render_node_cpu_usage,
},
{
itemId: 'wait',
iconCls: 'fa fa-fw fa-clock-o',
title: gettext('IO delay'),
valueField: 'wait',
rowspan: 2,
},
{
itemId: 'load',
iconCls: 'fa fa-fw fa-tasks',
title: gettext('Load average'),
printBar: false,
textField: 'loadavg',
},
{
xtype: 'box',
colspan: 2,
padding: '0 0 20 0',
},
{
iconCls: 'fa fa-fw pmx-itype-icon-memory pmx-icon',
itemId: 'memory',
title: gettext('RAM usage'),
valueField: 'memory',
maxField: 'memory',
renderer: Proxmox.Utils.render_node_size_usage,
},
{
itemId: 'ksm',
printBar: false,
title: gettext('KSM sharing'),
textField: 'ksm',
renderer: function(record) {
return Proxmox.Utils.render_size(record.shared);
},
padding: '0 10 10 10',
},
{
iconCls: 'fa fa-fw fa-hdd-o',
itemId: 'rootfs',
title: '/ ' + gettext('HD space'),
valueField: 'rootfs',
maxField: 'rootfs',
renderer: Proxmox.Utils.render_node_size_usage,
},
{
iconCls: 'fa fa-fw fa-refresh',
itemId: 'swap',
printSize: true,
title: gettext('SWAP usage'),
valueField: 'swap',
maxField: 'swap',
renderer: Proxmox.Utils.render_node_size_usage,
},
{
xtype: 'box',
colspan: 2,
padding: '0 0 20 0',
},
{
itemId: 'cpus',
colspan: 2,
printBar: false,
title: gettext('CPU(s)'),
textField: 'cpuinfo',
renderer: Proxmox.Utils.render_cpu_model,
value: '',
},
{
colspan: 2,
title: gettext('Kernel Version'),
printBar: false,
// TODO: remove with next major and only use newish current-kernel textfield
multiField: true,
//textField: 'current-kernel',
renderer: ({ data }) => {
if (!data['current-kernel']) {
return data.kversion;
}
let kernel = data['current-kernel'];
let buildDate = kernel.version.match(/\((.+)\)\s*$/)[1] ?? 'unknown';
return `${kernel.sysname} ${kernel.release} (${buildDate})`;
},
value: '',
},
{
colspan: 2,
title: gettext('Boot Mode'),
printBar: false,
textField: 'boot-info',
renderer: boot => {
if (boot.mode === 'legacy-bios') {
return 'Legacy BIOS';
} else if (boot.mode === 'efi') {
return `EFI${boot.secureboot ? ' (Secure Boot)' : ''}`;
}
return Proxmox.Utils.unknownText;
},
value: '',
},
{
itemId: 'version',
colspan: 2,
printBar: false,
title: gettext('Manager Version'),
textField: 'pveversion',
value: '',
},
],
updateTitle: function() {
var me = this;
var uptime = Proxmox.Utils.render_uptime(me.getRecordValue('uptime'));
me.setTitle(me.pveSelNode.data.node + ' (' + gettext('Uptime') + ': ' + uptime + ')');
},
initComponent: function() {
let me = this;
let stateProvider = Ext.state.Manager.getProvider();
let repoLink = stateProvider.encodeHToken({
view: "server",
rid: `node/${me.pveSelNode.data.node}`,
ltab: "tasks",
nodetab: "aptrepositories",
});
me.items.push({
xtype: 'pmxNodeInfoRepoStatus',
itemId: 'repositoryStatus',
product: 'Proxmox VE',
repoLink: `#${repoLink}`,
});
me.callParent();
},
});
Ext.define('PVE.node.SubscriptionKeyEdit', {
extend: 'Proxmox.window.Edit',
title: gettext('Upload Subscription Key'),
width: 350,
items: {
xtype: 'textfield',
name: 'key',
value: '',
fieldLabel: gettext('Subscription Key'),
labelWidth: 120,
getSubmitValue: function() {
return this.processRawValue(this.getRawValue())?.trim();
},
},
initComponent: function() {
var me = this;
me.callParent();
me.load();
},
});
Ext.define('PVE.node.Subscription', {
extend: 'Proxmox.grid.ObjectGrid',
alias: ['widget.pveNodeSubscription'],
onlineHelp: 'getting_help',
viewConfig: {
enableTextSelection: true,
},
showReport: function() {
var me = this;
var getReportFileName = function() {
var now = Ext.Date.format(new Date(), 'D-d-F-Y-G-i');
return `${me.nodename}-pve-report-${now}.txt`;
};
var view = Ext.createWidget('component', {
itemId: 'system-report-view',
scrollable: true,
style: {
'white-space': 'pre',
'font-family': 'monospace',
padding: '5px',
},
});
var reportWindow = Ext.create('Ext.window.Window', {
title: gettext('System Report'),
width: 1024,
height: 600,
layout: 'fit',
modal: true,
buttons: [
'->',
{
text: gettext('Download'),
handler: function() {
var fileContent = Ext.String.htmlDecode(reportWindow.getComponent('system-report-view').html);
var fileName = getReportFileName();
// Internet Explorer
if (window.navigator.msSaveOrOpenBlob) {
navigator.msSaveOrOpenBlob(new Blob([fileContent]), fileName);
} else {
var element = document.createElement('a');
element.setAttribute('href', 'data:text/plain;charset=utf-8,' +
encodeURIComponent(fileContent));
element.setAttribute('download', fileName);
element.style.display = 'none';
document.body.appendChild(element);
element.click();
document.body.removeChild(element);
}
},
},
],
items: view,
});
Proxmox.Utils.API2Request({
url: '/api2/extjs/nodes/' + me.nodename + '/report',
method: 'GET',
waitMsgTarget: me,
failure: function(response) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
},
success: function(response) {
var report = Ext.htmlEncode(response.result.data);
reportWindow.show();
view.update(report);
},
});
},
initComponent: function() {
var me = this;
if (!me.nodename) {
throw "no node name specified";
}
let rows = {
productname: {
header: gettext('Type'),
},
key: {
header: gettext('Subscription Key'),
},
status: {
header: gettext('Status'),
renderer: v => {
let message = me.getObjectValue('message');
return message ? `${v}: ${message}` : v;
},
},
message: {
visible: false,
},
serverid: {
header: gettext('Server ID'),
},
sockets: {
header: gettext('Sockets'),
},
checktime: {
header: gettext('Last checked'),
renderer: Proxmox.Utils.render_timestamp,
},
nextduedate: {
header: gettext('Next due date'),
},
signature: {
header: gettext('Signed/Offline'),
renderer: v => v ? gettext('Yes') : gettext('No'),
},
};
Ext.apply(me, {
url: `/api2/json/nodes/${me.nodename}/subscription`,
cwidth1: 170,
tbar: [
{
text: gettext('Upload Subscription Key'),
handler: () => Ext.create('PVE.node.SubscriptionKeyEdit', {
autoShow: true,
url: `/api2/extjs/nodes/${me.nodename}/subscription`,
listeners: {
destroy: () => me.rstore.load(),
},
}),
},
{
text: gettext('Check'),
handler: () => Proxmox.Utils.API2Request({
params: { force: 1 },
url: `/nodes/${me.nodename}/subscription`,
method: 'POST',
waitMsgTarget: me,
failure: response => Ext.Msg.alert(gettext('Error'), response.htmlStatus),
callback: () => me.rstore.load(),
}),
},
{
text: gettext('Remove Subscription'),
xtype: 'proxmoxStdRemoveButton',
confirmMsg: gettext('Are you sure you want to remove the subscription key?'),
baseurl: `/nodes/${me.nodename}/subscription`,
dangerous: true,
selModel: false,
callback: () => me.rstore.load(),
},
'-',
{
text: gettext('System Report'),
handler: function() {
Proxmox.Utils.checked_command(function() { me.showReport(); });
},
},
],
rows: rows,
listeners: {
activate: () => me.rstore.load(),
},
});
me.callParent();
},
});
Ext.define('PVE.node.Summary', {
extend: 'Ext.panel.Panel',
alias: 'widget.pveNodeSummary',
scrollable: true,
bodyPadding: 5,
showVersions: function() {
var me = this;
// Note: we use simply text/html here, because ExtJS grid has problems
// with cut&paste
var nodename = me.pveSelNode.data.node;
var view = Ext.createWidget('component', {
autoScroll: true,
id: 'pkgversions',
padding: 5,
style: {
'white-space': 'pre',
'font-family': 'monospace',
},
});
var win = Ext.create('Ext.window.Window', {
title: gettext('Package versions'),
width: 600,
height: 600,
layout: 'fit',
modal: true,
items: [view],
buttons: [
{
xtype: 'button',
iconCls: 'fa fa-clipboard',
handler: function(button) {
window.getSelection().selectAllChildren(
document.getElementById('pkgversions'),
);
document.execCommand("copy");
},
text: gettext('Copy'),
},
{
text: gettext('Ok'),
handler: function() {
this.up('window').close();
},
},
],
});
Proxmox.Utils.API2Request({
waitMsgTarget: me,
url: `/nodes/${nodename}/apt/versions`,
method: 'GET',
failure: function(response, opts) {
win.close();
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
},
success: function(response, opts) {
win.show();
let text = '';
Ext.Array.each(response.result.data, function(rec) {
let version = "not correctly installed";
let pkg = rec.Package;
if (rec.OldVersion && rec.CurrentState === 'Installed') {
version = rec.OldVersion;
}
if (rec.RunningKernel) {
text += `${pkg}: ${version} (running kernel: ${rec.RunningKernel})\n`;
} else if (rec.ManagerVersion) {
text += `${pkg}: ${version} (running version: ${rec.ManagerVersion})\n`;
} else {
text += `${pkg}: ${version}\n`;
}
});
view.update(Ext.htmlEncode(text));
},
});
},
updateRepositoryStatus: function() {
let me = this;
let repoStatus = me.nodeStatus.down('#repositoryStatus');
let nodename = me.pveSelNode.data.node;
Proxmox.Utils.API2Request({
url: `/nodes/${nodename}/apt/repositories`,
method: 'GET',
failure: response => Ext.Msg.alert(gettext('Error'), response.htmlStatus),
success: response => repoStatus.setRepositoryInfo(response.result.data['standard-repos']),
});
Proxmox.Utils.API2Request({
url: `/nodes/${nodename}/subscription`,
method: 'GET',
failure: response => Ext.Msg.alert(gettext('Error'), response.htmlStatus),
success: function(response, opts) {
const res = response.result;
const subscription = res?.data?.status.toLowerCase() === 'active';
repoStatus.setSubscriptionStatus(subscription);
},
});
},
initComponent: function() {
var me = this;
var nodename = me.pveSelNode.data.node;
if (!nodename) {
throw "no node name specified";
}
if (!me.statusStore) {
throw "no status storage specified";
}
var rstore = me.statusStore;
var version_btn = new Ext.Button({
text: gettext('Package versions'),
handler: function() {
Proxmox.Utils.checked_command(function() { me.showVersions(); });
},
});
var rrdstore = Ext.create('Proxmox.data.RRDStore', {
rrdurl: "/api2/json/nodes/" + nodename + "/rrddata",
model: 'pve-rrd-node',
});
let nodeStatus = Ext.create('PVE.node.StatusView', {
xtype: 'pveNodeStatus',
rstore: rstore,
width: 770,
pveSelNode: me.pveSelNode,
});
Ext.apply(me, {
tbar: [version_btn, '->', { xtype: 'proxmoxRRDTypeSelector' }],
nodeStatus: nodeStatus,
items: [
{
xtype: 'container',
itemId: 'itemcontainer',
layout: 'column',
minWidth: 700,
defaults: {
minHeight: 350,
padding: 5,
columnWidth: 1,
},
items: [
nodeStatus,
{
xtype: 'proxmoxRRDChart',
title: gettext('CPU usage'),
fields: ['cpu', 'iowait'],
fieldTitles: [gettext('CPU usage'), gettext('IO delay')],
unit: 'percent',
store: rrdstore,
},
{
xtype: 'proxmoxRRDChart',
title: gettext('Server load'),
fields: ['loadavg'],
fieldTitles: [gettext('Load average')],
store: rrdstore,
},
{
xtype: 'proxmoxRRDChart',
title: gettext('Memory usage'),
fields: ['memtotal', 'memused'],
fieldTitles: [gettext('Total'), gettext('RAM usage')],
unit: 'bytes',
powerOfTwo: true,
store: rrdstore,
},
{
xtype: 'proxmoxRRDChart',
title: gettext('Network traffic'),
fields: ['netin', 'netout'],
store: rrdstore,
},
],
listeners: {
resize: function(panel) {
Proxmox.Utils.updateColumns(panel);
},
},
},
],
listeners: {
activate: function() {
rstore.setInterval(1000);
rstore.startUpdate(); // just to be sure
rrdstore.startUpdate();
},
destroy: function() {
rstore.setInterval(5000); // don't stop it, it's not ours!
rrdstore.stopUpdate();
},
},
});
me.updateRepositoryStatus();
me.callParent();
let sp = Ext.state.Manager.getProvider();
me.mon(sp, 'statechange', function(provider, key, value) {
if (key !== 'summarycolumns') {
return;
}
Proxmox.Utils.updateColumns(me.getComponent('itemcontainer'));
});
},
});
Ext.define('PVE.node.CreateZFS', {
extend: 'Proxmox.window.Edit',
xtype: 'pveCreateZFS',
onlineHelp: 'chapter_zfs',
subject: 'ZFS',
showProgress: true,
isCreate: true,
width: 800,
viewModel: {
data: {
raidLevel: 'single',
},
formulas: {
isDraid: get => get('raidLevel')?.startsWith("draid"),
},
},
initComponent: function() {
let me = this;
if (!me.nodename) {
throw "no node name specified";
}
Ext.apply(me, {
url: `/nodes/${me.nodename}/disks/zfs`,
method: 'POST',
items: [
{
xtype: 'inputpanel',
onGetValues: function(values) {
if (values.draidData || values.draidSpares) {
let opt = { data: values.draidData, spares: values.draidSpares };
values['draid-config'] = PVE.Parser.printPropertyString(opt);
}
delete values.draidData;
delete values.draidSpares;
return values;
},
column1: [
{
xtype: 'proxmoxtextfield',
name: 'name',
fieldLabel: gettext('Name'),
allowBlank: false,
maxLength: 128, // ZFS_MAX_DATASET_NAME_LEN is (256 - some edge case)
validator: v => {
// see zpool_name_valid function in libzfs_zpool.c
if (v.match(/^(mirror|raidz|draid|spare)/) || v === 'log') {
return gettext('Cannot use reserved pool name');
} else if (!v.match(/^[a-zA-Z][a-zA-Z0-9\-_.]*$/)) {
// note: zfs would support also : and whitespace, but we don't
return gettext("Invalid characters in pool name");
}
return true;
},
},
{
xtype: 'proxmoxcheckbox',
name: 'add_storage',
fieldLabel: gettext('Add Storage'),
value: '1',
},
],
column2: [
{
xtype: 'proxmoxKVComboBox',
fieldLabel: gettext('RAID Level'),
name: 'raidlevel',
value: 'single',
comboItems: [
['single', gettext('Single Disk')],
['mirror', 'Mirror'],
['raid10', 'RAID10'],
['raidz', 'RAIDZ'],
['raidz2', 'RAIDZ2'],
['raidz3', 'RAIDZ3'],
['draid', 'dRAID'],
['draid2', 'dRAID2'],
['draid3', 'dRAID3'],
],
bind: {
value: '{raidLevel}',
},
},
{
xtype: 'proxmoxKVComboBox',
fieldLabel: gettext('Compression'),
name: 'compression',
value: 'on',
comboItems: [
['on', 'on'],
['off', 'off'],
['gzip', 'gzip'],
['lz4', 'lz4'],
['lzjb', 'lzjb'],
['zle', 'zle'],
['zstd', 'zstd'],
],
},
{
xtype: 'proxmoxintegerfield',
fieldLabel: gettext('ashift'),
minValue: 9,
maxValue: 16,
value: '12',
name: 'ashift',
},
],
columnB: [
{
xtype: 'fieldset',
title: gettext('dRAID Config'),
collapsible: false,
bind: {
hidden: '{!isDraid}',
},
layout: 'hbox',
padding: '5px 10px',
defaults: {
flex: 1,
layout: 'anchor',
},
items: [{
xtype: 'proxmoxintegerfield',
name: 'draidData',
fieldLabel: gettext('Data Devs'),
minValue: 1,
allowBlank: false,
disabled: true,
hidden: true,
bind: {
disabled: '{!isDraid}',
hidden: '{!isDraid}',
},
padding: '0 10 0 0',
},
{
xtype: 'proxmoxintegerfield',
name: 'draidSpares',
fieldLabel: gettext('Spares'),
minValue: 0,
allowBlank: false,
disabled: true,
hidden: true,
bind: {
disabled: '{!isDraid}',
hidden: '{!isDraid}',
},
padding: '0 0 0 10',
}],
},
{
xtype: 'pmxMultiDiskSelector',
name: 'devices',
nodename: me.nodename,
diskType: 'unused',
includePartitions: true,
height: 200,
emptyText: gettext('No Disks unused'),
itemId: 'disklist',
},
],
},
{
xtype: 'displayfield',
padding: '5 0 0 0',
userCls: 'pmx-hint',
value: 'Note: ZFS is not compatible with disks backed by a hardware ' +
'RAID controller. For details see the reference documentation .',
},
],
});
me.callParent();
},
});
Ext.define('PVE.node.ZFSList', {
extend: 'Ext.grid.Panel',
xtype: 'pveZFSList',
viewModel: {
data: {
pool: '',
},
},
controller: {
xclass: 'Ext.app.ViewController',
destroyPool: function() {
let me = this;
let vm = me.getViewModel();
let view = me.getView();
const pool = vm.get('pool');
if (!view.nodename) {
throw "no node name specified";
}
if (!pool) {
throw "no pool specified";
}
Ext.create('PVE.window.SafeDestroyStorage', {
url: `/nodes/${view.nodename}/disks/zfs/${pool}`,
item: { id: pool },
taskName: 'zfsremove',
taskDone: () => { view.reload(); },
}).show();
},
},
stateful: true,
stateId: 'grid-node-zfs',
columns: [
{
text: gettext('Name'),
dataIndex: 'name',
flex: 1,
},
{
header: gettext('Size'),
renderer: Proxmox.Utils.format_size,
dataIndex: 'size',
},
{
header: gettext('Free'),
renderer: Proxmox.Utils.format_size,
dataIndex: 'free',
},
{
header: gettext('Allocated'),
renderer: Proxmox.Utils.format_size,
dataIndex: 'alloc',
},
{
header: gettext('Fragmentation'),
renderer: function(value) {
return value.toString() + '%';
},
dataIndex: 'frag',
},
{
header: gettext('Health'),
renderer: PVE.Utils.render_zfs_health,
dataIndex: 'health',
},
{
header: gettext('Deduplication'),
hidden: true,
renderer: function(value) {
return value.toFixed(2).toString() + 'x';
},
dataIndex: 'dedup',
},
],
rootVisible: false,
useArrows: true,
tbar: [
{
text: gettext('Reload'),
iconCls: 'fa fa-refresh',
handler: function() {
this.up('panel').reload();
},
},
{
text: gettext('Create') + ': ZFS',
handler: function() {
let view = this.up('panel');
Ext.create('PVE.node.CreateZFS', {
nodename: view.nodename,
listeners: {
destroy: () => view.reload(),
},
autoShow: true,
});
},
},
{
text: gettext('Detail'),
itemId: 'detailbtn',
disabled: true,
handler: function() {
let view = this.up('panel');
let selection = view.getSelection();
if (selection.length) {
view.show_detail(selection[0].get('name'));
}
},
},
'->',
{
xtype: 'tbtext',
data: {
pool: undefined,
},
bind: {
data: {
pool: "{pool}",
},
},
tpl: [
'',
'Pool {pool}:',
'',
Ext.String.format(gettext('No {0} selected'), 'pool'),
' ',
],
},
{
text: gettext('More'),
iconCls: 'fa fa-bars',
disabled: true,
bind: {
disabled: '{!pool}',
},
menu: [
{
text: gettext('Destroy'),
itemId: 'remove',
iconCls: 'fa fa-fw fa-trash-o',
handler: 'destroyPool',
disabled: true,
bind: {
disabled: '{!pool}',
},
},
],
},
],
show_detail: function(zpool) {
let me = this;
Ext.create('Proxmox.window.ZFSDetail', {
zpool,
nodename: me.nodename,
}).show();
},
set_button_status: function() {
var me = this;
},
reload: function() {
var me = this;
me.store.load();
me.store.sort();
},
listeners: {
activate: function() {
this.reload();
},
selectionchange: function(model, selected) {
let me = this;
let vm = me.getViewModel();
me.down('#detailbtn').setDisabled(selected.length === 0);
vm.set('pool', selected[0]?.data.name || '');
},
itemdblclick: function(grid, record) {
this.show_detail(record.get('name'));
},
},
initComponent: function() {
let me = this;
me.nodename = me.pveSelNode.data.node;
if (!me.nodename) {
throw "no node name specified";
}
Ext.apply(me, {
store: {
fields: ['name', 'size', 'free', 'alloc', 'dedup', 'frag', 'health'],
proxy: {
type: 'proxmox',
url: `/api2/json/nodes/${me.nodename}/disks/zfs`,
},
sorters: 'name',
},
});
me.callParent();
Proxmox.Utils.monStoreErrors(me, me.getStore(), true);
me.reload();
},
});
Ext.define('Proxmox.node.NodeOptionsView', {
extend: 'Proxmox.grid.ObjectGrid',
alias: ['widget.proxmoxNodeOptionsView'],
mixins: ['Proxmox.Mixin.CBind'],
cbindData: function(_initialconfig) {
let me = this;
let baseUrl = `/nodes/${me.nodename}/config`;
me.url = `/api2/json${baseUrl}`;
me.editorConfig = {
url: `/api2/extjs/${baseUrl}`,
};
return {};
},
listeners: {
itemdblclick: function() { this.run_editor(); },
activate: function() { this.rstore.startUpdate(); },
destroy: function() { this.rstore.stopUpdate(); },
deactivate: function() { this.rstore.stopUpdate(); },
},
tbar: [
{
text: gettext('Edit'),
xtype: 'proxmoxButton',
disabled: true,
handler: btn => btn.up('grid').run_editor(),
},
],
gridRows: [
{
xtype: 'integer',
name: 'startall-onboot-delay',
text: gettext('Start on boot delay'),
minValue: 0,
maxValue: 300,
labelWidth: 130,
deleteEmpty: true,
renderer: function(value) {
if (value === undefined) {
return Proxmox.Utils.defaultText;
}
let secString = value === '1' ? gettext('Second') : gettext('Seconds');
return `${value} ${secString}`;
},
},
{
xtype: 'text',
name: 'wakeonlan',
text: gettext('MAC address for Wake on LAN'),
vtype: 'MacAddress',
labelWidth: 150,
deleteEmpty: true,
renderer: function(value) {
if (value === undefined) {
return Proxmox.Utils.NoneText;
}
return value;
},
},
],
});
Ext.define('PVE.pool.Config', {
extend: 'PVE.panel.Config',
alias: 'widget.pvePoolConfig',
onlineHelp: 'pveum_pools',
initComponent: function() {
var me = this;
var pool = me.pveSelNode.data.pool;
if (!pool) {
throw "no pool specified";
}
Ext.apply(me, {
title: Ext.String.format(gettext("Resource Pool") + ': ' + pool),
hstateid: 'pooltab',
items: [
{
title: gettext('Summary'),
iconCls: 'fa fa-book',
xtype: 'pvePoolSummary',
itemId: 'summary',
},
{
title: gettext('Members'),
xtype: 'pvePoolMembers',
iconCls: 'fa fa-th',
pool: pool,
itemId: 'members',
},
{
xtype: 'pveACLView',
title: gettext('Permissions'),
iconCls: 'fa fa-unlock',
itemId: 'permissions',
path: '/pool/' + pool,
},
],
});
me.callParent();
},
});
Ext.define('PVE.pool.StatusView', {
extend: 'Proxmox.grid.ObjectGrid',
alias: ['widget.pvePoolStatusView'],
disabled: true,
title: gettext('Status'),
cwidth1: 150,
interval: 30000,
//height: 195,
initComponent: function() {
var me = this;
var pool = me.pveSelNode.data.pool;
if (!pool) {
throw "no pool specified";
}
var rows = {
comment: {
header: gettext('Comment'),
renderer: Ext.String.htmlEncode,
required: true,
},
};
Ext.apply(me, {
url: "/api2/json/pools/?poolid=" + pool,
rows: rows,
});
me.callParent();
},
});
Ext.define('PVE.pool.Summary', {
extend: 'Ext.panel.Panel',
alias: 'widget.pvePoolSummary',
initComponent: function() {
var me = this;
var pool = me.pveSelNode.data.pool;
if (!pool) {
throw "no pool specified";
}
var statusview = Ext.create('PVE.pool.StatusView', {
pveSelNode: me.pveSelNode,
style: 'padding-top:0px',
});
var rstore = statusview.rstore;
Ext.apply(me, {
autoScroll: true,
bodyStyle: 'padding:10px',
defaults: {
style: 'padding-top:10px',
width: 800,
},
items: [statusview],
});
me.on('activate', rstore.startUpdate);
me.on('destroy', rstore.stopUpdate);
me.callParent();
},
});
Ext.define('PVE.window.IPInfo', {
extend: 'Ext.window.Window',
width: 600,
title: gettext('Guest Agent Network Information'),
height: 300,
layout: {
type: 'fit',
},
modal: true,
items: [
{
xtype: 'grid',
store: {},
emptyText: gettext('No network information'),
columns: [
{
dataIndex: 'name',
text: gettext('Name'),
flex: 3,
},
{
dataIndex: 'hardware-address',
text: gettext('MAC address'),
width: 140,
},
{
dataIndex: 'ip-addresses',
text: gettext('IP address'),
align: 'right',
flex: 4,
renderer: function(val) {
if (!Ext.isArray(val)) {
return '';
}
var ips = [];
val.forEach(function(ip) {
var addr = ip['ip-address'];
var pref = ip.prefix;
if (addr && pref) {
ips.push(addr + '/' + pref);
}
});
return ips.join('" + idx + " ";
}
},
},
{
xtype: 'checkcolumn',
header: gettext('Enabled'),
dataIndex: 'enabled',
flex: 4,
},
{
header: gettext('Device'),
dataIndex: 'name',
flex: 6,
renderer: (value, metaData, record, rowIndex) => {
let desc = record.get('desc');
let icon = '', iconCls;
if (value.match(/^net\d+$/)) {
iconCls = 'exchange';
} else if (desc.match(/media=cdrom/)) {
metaData.tdCls = 'pve-itype-icon-cdrom';
} else {
iconCls = 'hdd-o';
}
if (iconCls !== undefined) {
metaData.tdCls += 'pve-itype-fa';
icon = `(' + gettext('with options') + ') ';
}
text.push(key);
return;
}
// Most likely invalid at this point, so just stick to
// the old value.
text.push(Ext.String.htmlEncode(key));
}
});
if (text.length) {
return text.join('',
' ',
],
});
let tagsContainer = Ext.create('PVE.panel.TagEditContainer', {
tags: vm.tags,
canEdit: !!caps.vms['VM.Config.Options'],
listeners: {
change: function(tags) {
Proxmox.Utils.API2Request({
url: base_url + '/config',
method: 'PUT',
params: {
tags,
},
success: function() {
me.statusStore.load();
},
failure: function(response) {
Ext.Msg.alert('Error', response.htmlStatus);
me.statusStore.load();
},
});
},
},
});
let vm_text = `${vm.vmid} (${vm.name})`;
Ext.apply(me, {
title: Ext.String.format(gettext("Virtual Machine {0} on node '{1}'"), vm_text, nodename),
hstateid: 'kvmtab',
tbarSpacing: false,
tbar: [statusTxt, tagsContainer, '->', resumeBtn, startBtn, shutdownBtn, migrateBtn, consoleBtn, moreBtn],
defaults: { statusStore: me.statusStore },
items: [
{
title: gettext('Summary'),
xtype: 'pveGuestSummary',
iconCls: 'fa fa-book',
itemId: 'summary',
},
],
});
if (caps.vms['VM.Console'] && !template) {
me.items.push({
title: gettext('Console'),
itemId: 'console',
iconCls: 'fa fa-terminal',
xtype: 'pveNoVncConsole',
vmid: vmid,
consoleType: 'kvm',
nodename: nodename,
});
}
me.items.push(
{
title: gettext('Hardware'),
itemId: 'hardware',
iconCls: 'fa fa-desktop',
xtype: 'PVE.qemu.HardwareView',
},
{
title: 'Cloud-Init',
itemId: 'cloudinit',
iconCls: 'fa fa-cloud',
xtype: 'pveCiPanel',
},
{
title: gettext('Options'),
iconCls: 'fa fa-gear',
itemId: 'options',
xtype: 'PVE.qemu.Options',
},
{
title: gettext('Task History'),
itemId: 'tasks',
xtype: 'proxmoxNodeTasks',
iconCls: 'fa fa-list-alt',
nodename: nodename,
preFilter: {
vmid,
},
},
);
if (caps.vms['VM.Monitor'] && !template) {
me.items.push({
title: gettext('Monitor'),
iconCls: 'fa fa-eye',
itemId: 'monitor',
xtype: 'pveQemuMonitor',
});
}
if (caps.vms['VM.Backup']) {
me.items.push({
title: gettext('Backup'),
iconCls: 'fa fa-floppy-o',
xtype: 'pveBackupView',
itemId: 'backup',
},
{
title: gettext('Replication'),
iconCls: 'fa fa-retweet',
xtype: 'pveReplicaView',
itemId: 'replication',
});
}
if ((caps.vms['VM.Snapshot'] || caps.vms['VM.Snapshot.Rollback'] ||
caps.vms['VM.Audit']) && !template) {
me.items.push({
title: gettext('Snapshots'),
iconCls: 'fa fa-history',
type: 'qemu',
xtype: 'pveGuestSnapshotTree',
itemId: 'snapshot',
});
}
if (caps.vms['VM.Audit']) {
me.items.push(
{
xtype: 'pveFirewallRules',
title: gettext('Firewall'),
iconCls: 'fa fa-shield',
allow_iface: true,
base_url: base_url + '/firewall/rules',
list_refs_url: base_url + '/firewall/refs',
itemId: 'firewall',
},
{
xtype: 'pveFirewallOptions',
groups: ['firewall'],
iconCls: 'fa fa-gear',
onlineHelp: 'pve_firewall_vm_container_configuration',
title: gettext('Options'),
base_url: base_url + '/firewall/options',
fwtype: 'vm',
itemId: 'firewall-options',
},
{
xtype: 'pveFirewallAliases',
title: gettext('Alias'),
groups: ['firewall'],
iconCls: 'fa fa-external-link',
base_url: base_url + '/firewall/aliases',
itemId: 'firewall-aliases',
},
{
xtype: 'pveIPSet',
title: gettext('IPSet'),
groups: ['firewall'],
iconCls: 'fa fa-list-ol',
base_url: base_url + '/firewall/ipset',
list_refs_url: base_url + '/firewall/refs',
itemId: 'firewall-ipset',
},
);
}
if (caps.vms['VM.Console']) {
me.items.push(
{
title: gettext('Log'),
groups: ['firewall'],
iconCls: 'fa fa-list',
onlineHelp: 'chapter_pve_firewall',
itemId: 'firewall-fwlog',
xtype: 'proxmoxLogView',
url: '/api2/extjs' + base_url + '/firewall/log',
log_select_timespan: true,
submitFormat: 'U',
},
);
}
if (caps.vms['Permissions.Modify']) {
me.items.push({
xtype: 'pveACLView',
title: gettext('Permissions'),
iconCls: 'fa fa-unlock',
itemId: 'permissions',
path: '/vms/' + vmid,
});
}
me.callParent();
var prevQMPStatus = 'unknown';
me.mon(me.statusStore, 'load', function(s, records, success) {
var status;
var qmpstatus;
var spice = false;
var xtermjs = false;
var lock;
var rec;
if (!success) {
status = qmpstatus = 'unknown';
} else {
rec = s.data.get('status');
status = rec ? rec.data.value : 'unknown';
rec = s.data.get('qmpstatus');
qmpstatus = rec ? rec.data.value : 'unknown';
rec = s.data.get('template');
template = rec ? rec.data.value : false;
rec = s.data.get('lock');
lock = rec ? rec.data.value : undefined;
spice = !!s.data.get('spice');
xtermjs = !!s.data.get('serial');
}
rec = s.data.get('tags');
tagsContainer.loadTags(rec?.data?.value);
if (template) {
return;
}
var resume = ['prelaunch', 'paused', 'suspended'].indexOf(qmpstatus) !== -1;
if (resume || lock === 'suspended') {
startBtn.setVisible(false);
resumeBtn.setVisible(true);
} else {
startBtn.setVisible(true);
resumeBtn.setVisible(false);
}
consoleBtn.setEnableSpice(spice);
consoleBtn.setEnableXtermJS(xtermjs);
statusTxt.update({ lock: lock });
let guest_running = status === 'running' &&
!(qmpstatus === "shutdown" || qmpstatus === "prelaunch");
startBtn.setDisabled(!caps.vms['VM.PowerMgmt'] || template || guest_running);
shutdownBtn.setDisabled(!caps.vms['VM.PowerMgmt'] || status !== 'running');
me.down('#removeBtn').setDisabled(!caps.vms['VM.Allocate'] || status !== 'stopped');
consoleBtn.setDisabled(template);
let wasStopped = ['prelaunch', 'stopped', 'suspended'].indexOf(prevQMPStatus) !== -1;
if (wasStopped && qmpstatus === 'running') {
let con = me.down('#console');
if (con) {
con.reload();
}
}
prevQMPStatus = qmpstatus;
});
me.on('afterrender', function() {
me.statusStore.startUpdate();
});
me.on('destroy', function() {
me.statusStore.stopUpdate();
});
},
});
Ext.define('PVE.qemu.CreateWizard', {
extend: 'PVE.window.Wizard',
alias: 'widget.pveQemuCreateWizard',
mixins: ['Proxmox.Mixin.CBind'],
viewModel: {
data: {
nodename: '',
current: {
scsihw: '',
},
},
formulas: {
cgroupMode: function(get) {
const nodeInfo = PVE.data.ResourceStore.getNodes().find(
node => node.node === get('nodename'),
);
return nodeInfo ? nodeInfo['cgroup-mode'] : 2;
},
},
},
cbindData: {
nodename: undefined,
},
subject: gettext('Virtual Machine'),
// fot the special case that we have 2 cdrom drives
//
// emulates part of the backend bootorder logic, but includes all
// cdrom drives since we don't know which one the user put in a bootable iso
// and hardcodes the known values (ide0/2, net0)
calculateBootOrder: function(values) {
// user selected windows + second cdrom
if (values.ide0 && values.ide0.match(/media=cdrom/)) {
let disk;
PVE.Utils.forEachBus(['ide', 'scsi', 'virtio', 'sata'], (type, id) => {
let confId = type + id;
if (!values[confId]) {
return undefined;
}
if (values[confId].match(/media=cdrom/)) {
return undefined;
}
disk = confId;
return false; // abort loop
});
let order = [];
if (disk) {
order.push(disk);
}
order.push('ide0', 'ide2');
if (values.net0) {
order.push('net0');
}
return `order=${order.join(';')}`;
}
return undefined;
},
items: [
{
xtype: 'inputpanel',
title: gettext('General'),
onlineHelp: 'qm_general_settings',
column1: [
{
xtype: 'pveNodeSelector',
name: 'nodename',
cbind: {
selectCurNode: '{!nodename}',
preferredValue: '{nodename}',
},
bind: {
value: '{nodename}',
},
fieldLabel: gettext('Node'),
allowBlank: false,
onlineValidator: true,
},
{
xtype: 'pveGuestIDSelector',
name: 'vmid',
guestType: 'qemu',
value: '',
loadNextFreeID: true,
validateExists: false,
},
{
xtype: 'textfield',
name: 'name',
vtype: 'DnsName',
value: '',
fieldLabel: gettext('Name'),
allowBlank: true,
},
],
column2: [
{
xtype: 'pvePoolSelector',
fieldLabel: gettext('Resource Pool'),
name: 'pool',
value: '',
allowBlank: true,
},
],
advancedColumn1: [
{
xtype: 'proxmoxcheckbox',
name: 'onboot',
uncheckedValue: 0,
defaultValue: 0,
deleteDefaultValue: true,
fieldLabel: gettext('Start at boot'),
},
],
advancedColumn2: [
{
xtype: 'textfield',
name: 'order',
defaultValue: '',
emptyText: 'any',
labelWidth: 120,
fieldLabel: gettext('Start/Shutdown order'),
},
{
xtype: 'textfield',
name: 'up',
defaultValue: '',
emptyText: 'default',
labelWidth: 120,
fieldLabel: gettext('Startup delay'),
},
{
xtype: 'textfield',
name: 'down',
defaultValue: '',
emptyText: 'default',
labelWidth: 120,
fieldLabel: gettext('Shutdown timeout'),
},
],
advancedColumnB: [
{
xtype: 'pveTagFieldSet',
name: 'tags',
maxHeight: 150,
},
],
onGetValues: function(values) {
['name', 'pool', 'onboot', 'agent'].forEach(function(field) {
if (!values[field]) {
delete values[field];
}
});
var res = PVE.Parser.printStartup({
order: values.order,
up: values.up,
down: values.down,
});
if (res) {
values.startup = res;
}
delete values.order;
delete values.up;
delete values.down;
return values;
},
},
{
xtype: 'container',
layout: 'hbox',
defaults: {
flex: 1,
padding: '0 10',
},
title: gettext('OS'),
items: [
{
xtype: 'pveQemuCDInputPanel',
bind: {
nodename: '{nodename}',
},
confid: 'ide2',
insideWizard: true,
},
{
xtype: 'pveQemuOSTypePanel',
insideWizard: true,
bind: {
nodename: '{nodename}',
},
},
],
},
{
xtype: 'pveQemuSystemPanel',
title: gettext('System'),
isCreate: true,
insideWizard: true,
},
{
xtype: 'pveMultiHDPanel',
bind: {
nodename: '{nodename}',
},
title: gettext('Disks'),
},
{
xtype: 'pveQemuProcessorPanel',
insideWizard: true,
title: gettext('CPU'),
},
{
xtype: 'pveQemuMemoryPanel',
insideWizard: true,
title: gettext('Memory'),
},
{
xtype: 'pveQemuNetworkInputPanel',
bind: {
nodename: '{nodename}',
},
title: gettext('Network'),
insideWizard: true,
},
{
title: gettext('Confirm'),
layout: 'fit',
items: [
{
xtype: 'grid',
store: {
model: 'KeyValue',
sorters: [{
property: 'key',
direction: 'ASC',
}],
},
columns: [
{ header: 'Key', width: 150, dataIndex: 'key' },
{ header: 'Value', flex: 1, dataIndex: 'value' },
],
},
],
dockedItems: [
{
xtype: 'proxmoxcheckbox',
name: 'start',
dock: 'bottom',
margin: '5 0 0 0',
boxLabel: gettext('Start after created'),
},
],
listeners: {
show: function(panel) {
let wizard = this.up('window');
var kv = wizard.getValues();
var data = [];
let boot = wizard.calculateBootOrder(kv);
if (boot) {
kv.boot = boot;
}
Ext.Object.each(kv, function(key, value) {
if (key === 'delete') { // ignore
return;
}
data.push({ key: key, value: value });
});
var summarystore = panel.down('grid').getStore();
summarystore.suspendEvents();
summarystore.removeAll();
summarystore.add(data);
summarystore.sort();
summarystore.resumeEvents();
summarystore.fireEvent('refresh');
},
},
onSubmit: function() {
var wizard = this.up('window');
var kv = wizard.getValues();
delete kv.delete;
var nodename = kv.nodename;
delete kv.nodename;
let boot = wizard.calculateBootOrder(kv);
if (boot) {
kv.boot = boot;
}
Proxmox.Utils.API2Request({
url: '/nodes/' + nodename + '/qemu',
waitMsgTarget: wizard,
method: 'POST',
params: kv,
success: function(response) {
wizard.close();
},
failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
},
});
},
},
],
});
Ext.define('PVE.qemu.DisplayInputPanel', {
extend: 'Proxmox.panel.InputPanel',
xtype: 'pveDisplayInputPanel',
onlineHelp: 'qm_display',
onGetValues: function(values) {
let ret = PVE.Parser.printPropertyString(values, 'type');
if (ret === '') {
return { 'delete': 'vga' };
}
return { vga: ret };
},
items: [{
name: 'type',
xtype: 'proxmoxKVComboBox',
value: '__default__',
deleteEmpty: false,
fieldLabel: gettext('Graphic card'),
comboItems: Object.entries(PVE.Utils.kvm_vga_drivers),
validator: function(v) {
let cfg = this.up('proxmoxWindowEdit').vmconfig || {};
if (v.match(/^serial\d+$/) && (!cfg[v] || cfg[v] !== 'socket')) {
let fmt = gettext("Serial interface '{0}' is not correctly configured.");
return Ext.String.format(fmt, v);
}
return true;
},
listeners: {
change: function(cb, val) {
if (!val) {
return;
}
let memoryfield = this.up('panel').down('field[name=memory]');
let disableMemoryField = false;
if (val === "cirrus") {
memoryfield.setEmptyText("4");
} else if (val === "std" || val.match(/^qxl\d?$/) || val === "vmware") {
memoryfield.setEmptyText("16");
} else if (val.match(/^virtio/)) {
memoryfield.setEmptyText("256");
} else if (val.match(/^(serial\d|none)$/)) {
memoryfield.setEmptyText("N/A");
disableMemoryField = true;
} else {
console.debug("unexpected display type", val);
memoryfield.setEmptyText(Proxmox.Utils.defaultText);
}
memoryfield.setDisabled(disableMemoryField);
},
},
},
{
xtype: 'proxmoxintegerfield',
emptyText: Proxmox.Utils.defaultText,
fieldLabel: gettext('Memory') + ' (MiB)',
minValue: 4,
maxValue: 512,
step: 4,
name: 'memory',
}],
});
Ext.define('PVE.qemu.DisplayEdit', {
extend: 'Proxmox.window.Edit',
vmconfig: undefined,
subject: gettext('Display'),
width: 350,
items: [{
xtype: 'pveDisplayInputPanel',
}],
initComponent: function() {
let me = this;
me.callParent();
me.load({
success: function(response) {
me.vmconfig = response.result.data;
let vga = me.vmconfig.vga || '__default__';
me.setValues(PVE.Parser.parsePropertyString(vga, 'type'));
},
});
},
});
/* 'change' property is assigned a string and then a function */
Ext.define('PVE.qemu.HDInputPanel', {
extend: 'Proxmox.panel.InputPanel',
alias: 'widget.pveQemuHDInputPanel',
onlineHelp: 'qm_hard_disk',
insideWizard: false,
unused: false, // ADD usused disk imaged
vmconfig: {}, // used to select usused disks
viewModel: {
data: {
isSCSI: false,
isVirtIO: false,
isSCSISingle: false,
},
},
controller: {
xclass: 'Ext.app.ViewController',
onControllerChange: function(field) {
let me = this;
let vm = this.getViewModel();
let value = field.getValue();
vm.set('isSCSI', value.match(/^scsi/));
vm.set('isVirtIO', value.match(/^virtio/));
me.fireIdChange();
},
fireIdChange: function() {
let view = this.getView();
view.fireEvent('diskidchange', view, view.bussel.getConfId());
},
control: {
'field[name=controller]': {
change: 'onControllerChange',
afterrender: 'onControllerChange',
},
'field[name=deviceid]': {
change: 'fireIdChange',
},
'field[name=scsiController]': {
change: function(f, value) {
let vm = this.getViewModel();
vm.set('isSCSISingle', value === 'virtio-scsi-single');
},
},
},
init: function(view) {
var vm = this.getViewModel();
if (view.isCreate) {
vm.set('isIncludedInBackup', true);
}
if (view.confid) {
vm.set('isSCSI', view.confid.match(/^scsi/));
vm.set('isVirtIO', view.confid.match(/^virtio/));
}
},
},
onGetValues: function(values) {
var me = this;
var params = {};
var confid = me.confid || values.controller + values.deviceid;
if (me.unused) {
me.drive.file = me.vmconfig[values.unusedId];
confid = values.controller + values.deviceid;
} else if (me.isCreate) {
if (values.hdimage) {
me.drive.file = values.hdimage;
} else {
me.drive.file = values.hdstorage + ":" + values.disksize;
}
me.drive.format = values.diskformat;
}
PVE.Utils.propertyStringSet(me.drive, !values.backup, 'backup', '0');
PVE.Utils.propertyStringSet(me.drive, values.noreplicate, 'replicate', 'no');
PVE.Utils.propertyStringSet(me.drive, values.discard, 'discard', 'on');
PVE.Utils.propertyStringSet(me.drive, values.ssd, 'ssd', 'on');
PVE.Utils.propertyStringSet(me.drive, values.iothread, 'iothread', 'on');
PVE.Utils.propertyStringSet(me.drive, values.readOnly, 'ro', 'on');
PVE.Utils.propertyStringSet(me.drive, values.cache, 'cache');
PVE.Utils.propertyStringSet(me.drive, values.aio, 'aio');
['mbps_rd', 'mbps_wr', 'iops_rd', 'iops_wr'].forEach(name => {
let burst_name = `${name}_max`;
PVE.Utils.propertyStringSet(me.drive, values[name], name);
PVE.Utils.propertyStringSet(me.drive, values[burst_name], burst_name);
});
params[confid] = PVE.Parser.printQemuDrive(me.drive);
return params;
},
updateVMConfig: function(vmconfig) {
var me = this;
me.vmconfig = vmconfig;
me.bussel?.updateVMConfig(vmconfig);
},
setVMConfig: function(vmconfig) {
var me = this;
me.vmconfig = vmconfig;
if (me.bussel) {
me.bussel.setVMConfig(vmconfig);
me.scsiController.setValue(vmconfig.scsihw);
}
if (me.unusedDisks) {
var disklist = [];
Ext.Object.each(vmconfig, function(key, value) {
if (key.match(/^unused\d+$/)) {
disklist.push([key, value]);
}
});
me.unusedDisks.store.loadData(disklist);
me.unusedDisks.setValue(me.confid);
}
},
setDrive: function(drive) {
var me = this;
me.drive = drive;
var values = {};
var match = drive.file.match(/^([^:]+):/);
if (match) {
values.hdstorage = match[1];
}
values.hdimage = drive.file;
values.backup = PVE.Parser.parseBoolean(drive.backup, 1);
values.noreplicate = !PVE.Parser.parseBoolean(drive.replicate, 1);
values.diskformat = drive.format || 'raw';
values.cache = drive.cache || '__default__';
values.discard = drive.discard === 'on';
values.ssd = PVE.Parser.parseBoolean(drive.ssd);
values.iothread = PVE.Parser.parseBoolean(drive.iothread);
values.readOnly = PVE.Parser.parseBoolean(drive.ro);
values.aio = drive.aio || '__default__';
values.mbps_rd = drive.mbps_rd;
values.mbps_wr = drive.mbps_wr;
values.iops_rd = drive.iops_rd;
values.iops_wr = drive.iops_wr;
values.mbps_rd_max = drive.mbps_rd_max;
values.mbps_wr_max = drive.mbps_wr_max;
values.iops_rd_max = drive.iops_rd_max;
values.iops_wr_max = drive.iops_wr_max;
me.setValues(values);
},
setNodename: function(nodename) {
var me = this;
me.down('#hdstorage').setNodename(nodename);
me.down('#hdimage').setStorage(undefined, nodename);
},
hasAdvanced: true,
initComponent: function() {
var me = this;
me.drive = {};
let column1 = [];
let column2 = [];
let advancedColumn1 = [];
let advancedColumn2 = [];
if (!me.confid || me.unused) {
me.bussel = Ext.create('PVE.form.ControllerSelector', {
vmconfig: me.vmconfig,
selectFree: true,
});
column1.push(me.bussel);
me.scsiController = Ext.create('Ext.form.field.Display', {
fieldLabel: gettext('SCSI Controller'),
reference: 'scsiController',
name: 'scsiController',
bind: me.insideWizard ? {
value: '{current.scsihw}',
visible: '{isSCSI}',
} : {
visible: '{isSCSI}',
},
renderer: PVE.Utils.render_scsihw,
submitValue: false,
hidden: true,
});
column1.push(me.scsiController);
}
if (me.unused) {
me.unusedDisks = Ext.create('Proxmox.form.KVComboBox', {
name: 'unusedId',
fieldLabel: gettext('Disk image'),
matchFieldWidth: false,
listConfig: {
width: 350,
},
data: [],
allowBlank: false,
});
column1.push(me.unusedDisks);
} else if (me.isCreate) {
column1.push({
xtype: 'pveDiskStorageSelector',
storageContent: 'images',
name: 'disk',
nodename: me.nodename,
autoSelect: me.insideWizard,
});
} else {
column1.push({
xtype: 'textfield',
disabled: true,
submitValue: false,
fieldLabel: gettext('Disk image'),
name: 'hdimage',
});
}
column2.push(
{
xtype: 'CacheTypeSelector',
name: 'cache',
value: '__default__',
fieldLabel: gettext('Cache'),
},
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Discard'),
reference: 'discard',
name: 'discard',
},
{
xtype: 'proxmoxcheckbox',
name: 'iothread',
fieldLabel: 'IO thread',
clearOnDisable: true,
bind: me.insideWizard || me.isCreate ? {
disabled: '{!isVirtIO && !isSCSI}',
// Checkbox.setValue handles Arrays in a different way, therefore cast to bool
value: '{!!isVirtIO || (isSCSI && isSCSISingle)}',
} : {
disabled: '{!isVirtIO && !isSCSI}',
},
},
);
advancedColumn1.push(
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('SSD emulation'),
name: 'ssd',
clearOnDisable: true,
bind: {
disabled: '{isVirtIO}',
},
},
{
xtype: 'proxmoxcheckbox',
name: 'readOnly', // `ro` in the config, we map in get/set values
defaultValue: 0,
fieldLabel: gettext('Read-only'),
clearOnDisable: true,
bind: {
disabled: '{!isVirtIO && !isSCSI}',
},
},
);
advancedColumn2.push(
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Backup'),
autoEl: {
tag: 'div',
'data-qtip': gettext('Include volume in backup job'),
},
name: 'backup',
bind: {
value: '{isIncludedInBackup}',
},
},
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Skip replication'),
name: 'noreplicate',
},
{
xtype: 'proxmoxKVComboBox',
name: 'aio',
fieldLabel: gettext('Async IO'),
allowBlank: false,
value: '__default__',
comboItems: [
['__default__', Proxmox.Utils.defaultText + ' (io_uring)'],
['io_uring', 'io_uring'],
['native', 'native'],
['threads', 'threads'],
],
},
);
let labelWidth = 140;
let bwColumn1 = [
{
xtype: 'numberfield',
name: 'mbps_rd',
minValue: 1,
step: 1,
fieldLabel: gettext('Read limit') + ' (MB/s)',
labelWidth: labelWidth,
emptyText: gettext('unlimited'),
},
{
xtype: 'numberfield',
name: 'mbps_wr',
minValue: 1,
step: 1,
fieldLabel: gettext('Write limit') + ' (MB/s)',
labelWidth: labelWidth,
emptyText: gettext('unlimited'),
},
{
xtype: 'proxmoxintegerfield',
name: 'iops_rd',
minValue: 10,
step: 10,
fieldLabel: gettext('Read limit') + ' (ops/s)',
labelWidth: labelWidth,
emptyText: gettext('unlimited'),
},
{
xtype: 'proxmoxintegerfield',
name: 'iops_wr',
minValue: 10,
step: 10,
fieldLabel: gettext('Write limit') + ' (ops/s)',
labelWidth: labelWidth,
emptyText: gettext('unlimited'),
},
];
let bwColumn2 = [
{
xtype: 'numberfield',
name: 'mbps_rd_max',
minValue: 1,
step: 1,
fieldLabel: gettext('Read max burst') + ' (MB)',
labelWidth: labelWidth,
emptyText: gettext('default'),
},
{
xtype: 'numberfield',
name: 'mbps_wr_max',
minValue: 1,
step: 1,
fieldLabel: gettext('Write max burst') + ' (MB)',
labelWidth: labelWidth,
emptyText: gettext('default'),
},
{
xtype: 'proxmoxintegerfield',
name: 'iops_rd_max',
minValue: 10,
step: 10,
fieldLabel: gettext('Read max burst') + ' (ops)',
labelWidth: labelWidth,
emptyText: gettext('default'),
},
{
xtype: 'proxmoxintegerfield',
name: 'iops_wr_max',
minValue: 10,
step: 10,
fieldLabel: gettext('Write max burst') + ' (ops)',
labelWidth: labelWidth,
emptyText: gettext('default'),
},
];
me.items = [
{
xtype: 'tabpanel',
plain: true,
bodyPadding: 10,
border: 0,
items: [
{
title: gettext('Disk'),
xtype: 'inputpanel',
reference: 'diskpanel',
column1,
column2,
advancedColumn1,
advancedColumn2,
showAdvanced: me.showAdvanced,
getValues: () => ({}),
},
{
title: gettext('Bandwidth'),
xtype: 'inputpanel',
reference: 'bwpanel',
column1: bwColumn1,
column2: bwColumn2,
showAdvanced: me.showAdvanced,
getValues: () => ({}),
},
],
},
];
me.callParent();
},
setAdvancedVisible: function(visible) {
this.lookup('diskpanel').setAdvancedVisible(visible);
this.lookup('bwpanel').setAdvancedVisible(visible);
},
});
Ext.define('PVE.qemu.HDEdit', {
extend: 'Proxmox.window.Edit',
isAdd: true,
backgroundDelay: 5,
width: 600,
bodyPadding: 0,
initComponent: function() {
var me = this;
var nodename = me.pveSelNode.data.node;
if (!nodename) {
throw "no node name specified";
}
var unused = me.confid && me.confid.match(/^unused\d+$/);
me.isCreate = me.confid ? unused : true;
var ipanel = Ext.create('PVE.qemu.HDInputPanel', {
confid: me.confid,
nodename: nodename,
unused: unused,
isCreate: me.isCreate,
});
if (unused) {
me.subject = gettext('Unused Disk');
} else if (me.isCreate) {
me.subject = gettext('Hard Disk');
} else {
me.subject = gettext('Hard Disk') + ' (' + me.confid + ')';
}
me.items = [ipanel];
me.callParent();
/* 'data' is assigned an empty array in same file, and here we
* use it like an object
*/
me.load({
success: function(response, options) {
ipanel.setVMConfig(response.result.data);
if (me.confid) {
var value = response.result.data[me.confid];
var drive = PVE.Parser.parseQemuDrive(me.confid, value);
if (!drive) {
Ext.Msg.alert(gettext('Error'), 'Unable to parse drive options');
me.close();
return;
}
ipanel.setDrive(drive);
me.isValid(); // trigger validation
}
},
});
},
});
Ext.define('PVE.qemu.EFIDiskInputPanel', {
extend: 'Proxmox.panel.InputPanel',
alias: 'widget.pveEFIDiskInputPanel',
insideWizard: false,
unused: false, // ADD usused disk imaged
vmconfig: {}, // used to select usused disks
onGetValues: function(values) {
var me = this;
if (me.disabled) {
return {};
}
var confid = 'efidisk0';
if (values.hdimage) {
me.drive.file = values.hdimage;
} else {
// we use 1 here, because for efi the size gets overridden from the backend
me.drive.file = values.hdstorage + ":1";
}
// always default to newer 4m type with secure boot support, if we're
// adding a new EFI disk there can't be any old state anyway
me.drive.efitype = '4m';
me.drive['pre-enrolled-keys'] = values.preEnrolledKeys;
delete values.preEnrolledKeys;
me.drive.format = values.diskformat;
let params = {};
params[confid] = PVE.Parser.printQemuDrive(me.drive);
return params;
},
setNodename: function(nodename) {
var me = this;
me.down('#hdstorage').setNodename(nodename);
me.down('#hdimage').setStorage(undefined, nodename);
},
setDisabled: function(disabled) {
let me = this;
me.down('pveDiskStorageSelector').setDisabled(disabled);
me.down('proxmoxcheckbox[name=preEnrolledKeys]').setDisabled(disabled);
me.callParent(arguments);
},
initComponent: function() {
var me = this;
me.drive = {};
me.items = [
{
xtype: 'pveDiskStorageSelector',
name: 'efidisk0',
storageLabel: gettext('EFI Storage'),
storageContent: 'images',
nodename: me.nodename,
disabled: me.disabled,
hideSize: true,
},
{
xtype: 'proxmoxcheckbox',
name: 'preEnrolledKeys',
checked: true,
fieldLabel: gettext("Pre-Enroll keys"),
disabled: me.disabled,
//boxLabel: '(e.g., Microsoft secure-boot keys')',
autoEl: {
tag: 'div',
'data-qtip': gettext('Use EFIvars image with standard distribution and Microsoft secure boot keys enrolled.'),
},
},
{
xtype: 'label',
text: gettext("Warning: The VM currently does not uses 'OVMF (UEFI)' as BIOS."),
userCls: 'pmx-hint',
hidden: me.usesEFI,
},
];
me.callParent();
},
});
Ext.define('PVE.qemu.EFIDiskEdit', {
extend: 'Proxmox.window.Edit',
isAdd: true,
subject: gettext('EFI Disk'),
width: 450,
initComponent: function() {
var me = this;
var nodename = me.pveSelNode.data.node;
if (!nodename) {
throw "no node name specified";
}
me.items = [{
xtype: 'pveEFIDiskInputPanel',
onlineHelp: 'qm_bios_and_uefi',
confid: me.confid,
nodename: nodename,
usesEFI: me.usesEFI,
isCreate: true,
}];
me.callParent();
},
});
Ext.define('PVE.qemu.TPMDiskInputPanel', {
extend: 'Proxmox.panel.InputPanel',
alias: 'widget.pveTPMDiskInputPanel',
unused: false,
vmconfig: {},
onGetValues: function(values) {
var me = this;
if (me.disabled) {
return {};
}
var confid = 'tpmstate0';
if (values.hdimage) {
me.drive.file = values.hdimage;
} else {
// size is constant, so just use 1
me.drive.file = values.hdstorage + ":1";
}
me.drive.version = values.version;
var params = {};
params[confid] = PVE.Parser.printQemuDrive(me.drive);
return params;
},
setNodename: function(nodename) {
var me = this;
me.down('#hdstorage').setNodename(nodename);
me.down('#hdimage').setStorage(undefined, nodename);
},
setDisabled: function(disabled) {
let me = this;
me.down('pveDiskStorageSelector').setDisabled(disabled);
me.down('proxmoxKVComboBox[name=version]').setDisabled(disabled);
me.callParent(arguments);
},
initComponent: function() {
var me = this;
me.drive = {};
me.items = [
{
xtype: 'pveDiskStorageSelector',
name: me.disktype + '0',
storageLabel: gettext('TPM Storage'),
storageContent: 'images',
nodename: me.nodename,
disabled: me.disabled,
hideSize: true,
hideFormat: true,
},
{
xtype: 'proxmoxKVComboBox',
name: 'version',
value: 'v2.0',
fieldLabel: gettext('Version'),
deleteEmpty: false,
disabled: me.disabled,
comboItems: [
['v1.2', 'v1.2'],
['v2.0', 'v2.0'],
],
},
];
me.callParent();
},
});
Ext.define('PVE.qemu.TPMDiskEdit', {
extend: 'Proxmox.window.Edit',
isAdd: true,
subject: gettext('TPM State'),
width: 450,
initComponent: function() {
var me = this;
var nodename = me.pveSelNode.data.node;
if (!nodename) {
throw "no node name specified";
}
me.items = [{
xtype: 'pveTPMDiskInputPanel',
//onlineHelp: 'qm_tpm', FIXME: add once available
confid: me.confid,
nodename: nodename,
isCreate: true,
}];
me.callParent();
},
});
Ext.define('PVE.window.HDMove', {
extend: 'Proxmox.window.Edit',
mixins: ['Proxmox.Mixin.CBind'],
resizable: false,
modal: true,
width: 350,
border: false,
layout: 'fit',
showReset: false,
showTaskViewer: true,
method: 'POST',
cbindData: function() {
let me = this;
return {
disk: me.disk,
isQemu: me.type === 'qemu',
nodename: me.nodename,
url: () => {
let endpoint = me.type === 'qemu' ? 'move_disk' : 'move_volume';
return `/nodes/${me.nodename}/${me.type}/${me.vmid}/${endpoint}`;
},
};
},
cbind: {
title: get => get('isQemu') ? gettext("Move disk") : gettext('Move Volume'),
submitText: get => get('title'),
qemu: '{isQemu}',
url: '{url}',
},
getValues: function() {
let me = this;
let values = me.formPanel.getForm().getValues();
let params = {
storage: values.hdstorage,
};
params[me.qemu ? 'disk' : 'volume'] = me.disk;
if (values.diskformat && me.qemu) {
params.format = values.diskformat;
}
if (values.deleteDisk) {
params.delete = 1;
}
return params;
},
items: [
{
xtype: 'form',
reference: 'moveFormPanel',
border: false,
fieldDefaults: {
labelWidth: 100,
anchor: '100%',
},
items: [
{
xtype: 'displayfield',
cbind: {
name: get => get('isQemu') ? 'disk' : 'volume',
fieldLabel: get => get('isQemu') ? gettext('Disk') : gettext('Mount Point'),
value: '{disk}',
},
allowBlank: false,
},
{
xtype: 'pveDiskStorageSelector',
storageLabel: gettext('Target Storage'),
cbind: {
nodename: '{nodename}',
storageContent: get => get('isQemu') ? 'images' : 'rootdir',
hideFormat: get => get('disk') === 'tpmstate0',
},
hideSize: true,
},
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Delete source'),
name: 'deleteDisk',
uncheckedValue: 0,
checked: false,
},
],
},
],
initComponent: function() {
let me = this;
if (!me.nodename) {
throw "no node name specified";
}
if (!me.vmid) {
throw "no VM ID specified";
}
if (!me.type) {
throw "no type specified";
}
me.callParent();
},
});
Ext.define('PVE.window.HDResize', {
extend: 'Ext.window.Window',
resizable: false,
resize_disk: function(disk, size) {
var me = this;
var params = { disk: disk, size: '+' + size + 'G' };
Proxmox.Utils.API2Request({
params: params,
url: '/nodes/' + me.nodename + '/qemu/' + me.vmid + '/resize',
waitMsgTarget: me,
method: 'PUT',
failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
},
success: function(response, options) {
Ext.create('Proxmox.window.TaskProgress', {
autoShow: true,
upid: response.result.data,
});
me.close();
},
});
},
initComponent: function() {
var me = this;
if (!me.nodename) {
throw "no node name specified";
}
if (!me.vmid) {
throw "no VM ID specified";
}
var items = [
{
xtype: 'displayfield',
name: 'disk',
value: me.disk,
fieldLabel: gettext('Disk'),
vtype: 'StorageId',
allowBlank: false,
},
];
me.hdsizesel = Ext.createWidget('numberfield', {
name: 'size',
minValue: 0,
maxValue: 128*1024,
decimalPrecision: 3,
value: '0',
fieldLabel: `${gettext('Size Increment')} (${gettext('GiB')})`,
allowBlank: false,
});
items.push(me.hdsizesel);
me.formPanel = Ext.create('Ext.form.Panel', {
bodyPadding: 10,
border: false,
fieldDefaults: {
labelWidth: 140,
anchor: '100%',
},
items: items,
});
var form = me.formPanel.getForm();
var submitBtn;
me.title = gettext('Resize disk');
submitBtn = Ext.create('Ext.Button', {
text: gettext('Resize disk'),
handler: function() {
if (form.isValid()) {
var values = form.getValues();
me.resize_disk(me.disk, values.size);
}
},
});
Ext.apply(me, {
modal: true,
width: 250,
height: 150,
border: false,
layout: 'fit',
buttons: [submitBtn],
items: [me.formPanel],
});
me.callParent();
},
});
Ext.define('PVE.qemu.HardwareView', {
extend: 'Proxmox.grid.PendingObjectGrid',
alias: ['widget.PVE.qemu.HardwareView'],
onlineHelp: 'qm_virtual_machines_settings',
renderKey: function(key, metaData, rec, rowIndex, colIndex, store) {
var me = this;
var rows = me.rows;
var rowdef = rows[key] || {};
var iconCls = rowdef.iconCls;
var icon = '';
var txt = rowdef.header || key;
metaData.tdAttr = "valign=middle";
if (rowdef.isOnStorageBus) {
var value = me.getObjectValue(key, '', false);
if (value === '') {
value = me.getObjectValue(key, '', true);
}
if (value.match(/vm-.*-cloudinit/)) {
iconCls = 'cloud';
txt = rowdef.cloudheader;
} else if (value.match(/media=cdrom/)) {
metaData.tdCls = 'pve-itype-icon-cdrom';
return rowdef.cdheader;
}
}
if (rowdef.tdCls) {
metaData.tdCls = rowdef.tdCls;
} else if (iconCls) {
icon = "${commands.flat(2).join('\n')} `);
scrollToEnd();
};
let recordInput = line => {
commands.push([line]);
// drop oldest commands and their output until we're not over both limits anymore
while (commands.length > me.commandLimit && commands.flat(2).length > me.lineLimit) {
commands.shift();
}
};
let addResponse = lines => commands[commands.length - 1].push(lines);
var executeCmd = function(cmd) {
recordInput("# " + Ext.htmlEncode(cmd), true);
if (cmd) {
history.unshift(cmd);
if (history.length > 20) {
history.splice(20);
}
}
histNum = -1;
refresh();
Proxmox.Utils.API2Request({
params: { command: cmd },
url: '/nodes/' + nodename + '/qemu/' + vmid + "/monitor",
method: 'POST',
waitMsgTarget: me,
success: function(response, opts) {
var res = response.result.data;
addResponse(res.split('\n').map(line => Ext.htmlEncode(line)));
refresh();
},
failure: function(response, opts) {
Ext.Msg.alert('Error', response.htmlStatus);
},
});
};
Ext.apply(me, {
layout: { type: 'border' },
border: false,
items: [
textbox,
{
region: 'south',
margins: '0 5 5 5',
border: false,
xtype: 'textfield',
name: 'cmd',
value: '',
fieldStyle: 'font-family: monospace;',
allowBlank: true,
listeners: {
afterrender: function(f) {
f.focus(false);
recordInput("Type 'help' for help.");
refresh();
},
specialkey: function(f, e) {
var key = e.getKey();
switch (key) {
case e.ENTER:
var cmd = f.getValue();
f.setValue('');
executeCmd(cmd);
break;
case e.PAGE_UP:
textbox.scrollBy(0, -0.9*textbox.getHeight(), false);
break;
case e.PAGE_DOWN:
textbox.scrollBy(0, 0.9*textbox.getHeight(), false);
break;
case e.UP:
if (histNum + 1 < history.length) {
f.setValue(history[++histNum]);
}
e.preventDefault();
break;
case e.DOWN:
if (histNum > 0) {
f.setValue(history[--histNum]);
}
e.preventDefault();
break;
default:
break;
}
},
},
},
],
listeners: {
show: function() {
var field = me.query('textfield[name="cmd"]')[0];
field.focus(false, true);
},
},
});
me.callParent();
},
});
Ext.define('PVE.qemu.MultiHDPanel', {
extend: 'PVE.panel.MultiDiskPanel',
alias: 'widget.pveMultiHDPanel',
onlineHelp: 'qm_hard_disk',
controller: {
xclass: 'Ext.app.ViewController',
// maxCount is the sum of all controller ids - 1 (ide2 is fixed in the wizard)
maxCount: Object.values(PVE.Utils.diskControllerMaxIDs)
.reduce((previous, current) => previous+current, 0) - 1,
getNextFreeDisk: function(vmconfig) {
let clist = PVE.Utils.sortByPreviousUsage(vmconfig);
return PVE.Utils.nextFreeDisk(clist, vmconfig);
},
addPanel: function(itemId, vmconfig, nextFreeDisk) {
let me = this;
return me.getView().add({
vmconfig,
border: false,
showAdvanced: Ext.state.Manager.getProvider().get('proxmox-advanced-cb'),
xtype: 'pveQemuHDInputPanel',
bind: {
nodename: '{nodename}',
},
padding: '0 0 0 5',
itemId,
isCreate: true,
insideWizard: true,
});
},
getBaseVMConfig: function() {
let me = this;
let vm = me.getViewModel();
let res = {
ide2: 'media=cdrom',
scsihw: vm.get('current.scsihw'),
ostype: vm.get('current.ostype'),
};
if (vm.get('current.ide0') === "some") {
res.ide0 = "media=cdrom";
}
return res;
},
diskSorter: {
sorterFn: function(rec1, rec2) {
let [, name1, id1] = PVE.Utils.bus_match.exec(rec1.data.name);
let [, name2, id2] = PVE.Utils.bus_match.exec(rec2.data.name);
if (name1 === name2) {
return parseInt(id1, 10) - parseInt(id2, 10);
}
return name1 < name2 ? -1 : 1;
},
},
deleteDisabled: () => false,
},
});
Ext.define('PVE.qemu.NetworkInputPanel', {
extend: 'Proxmox.panel.InputPanel',
alias: 'widget.pveQemuNetworkInputPanel',
onlineHelp: 'qm_network_device',
insideWizard: false,
onGetValues: function(values) {
var me = this;
me.network.model = values.model;
if (values.nonetwork) {
return {};
} else {
me.network.bridge = values.bridge;
me.network.tag = values.tag;
me.network.firewall = values.firewall;
}
me.network.macaddr = values.macaddr;
me.network.disconnect = values.disconnect;
me.network.queues = values.queues;
me.network.mtu = values.mtu;
if (values.rate) {
me.network.rate = values.rate;
} else {
delete me.network.rate;
}
var params = {};
params[me.confid] = PVE.Parser.printQemuNetwork(me.network);
return params;
},
viewModel: {
data: {
networkModel: undefined,
mtu: '',
},
formulas: {
isVirtio: get => get('networkModel') === 'virtio',
showMtuHint: get => get('mtu') === 1,
},
},
setNetwork: function(confid, data) {
var me = this;
me.confid = confid;
if (data) {
data.networkmode = data.bridge ? 'bridge' : 'nat';
} else {
data = {};
data.networkmode = 'bridge';
}
me.network = data;
me.setValues(me.network);
},
setNodename: function(nodename) {
var me = this;
me.bridgesel.setNodename(nodename);
},
initComponent: function() {
var me = this;
me.network = {};
me.confid = 'net0';
me.column1 = [];
me.column2 = [];
me.bridgesel = Ext.create('PVE.form.BridgeSelector', {
name: 'bridge',
fieldLabel: gettext('Bridge'),
nodename: me.nodename,
autoSelect: true,
allowBlank: false,
});
me.column1 = [
me.bridgesel,
{
xtype: 'pveVlanField',
name: 'tag',
value: '',
},
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Firewall'),
name: 'firewall',
checked: me.insideWizard || me.isCreate,
},
];
me.advancedColumn1 = [
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Disconnect'),
name: 'disconnect',
},
{
xtype: 'proxmoxintegerfield',
name: 'mtu',
fieldLabel: 'MTU',
bind: {
disabled: '{!isVirtio}',
value: '{mtu}',
},
emptyText: '1500 (1 = bridge MTU)',
minValue: 1,
maxValue: 65520,
allowBlank: true,
validator: val => val === '' || val >= 576 || val === '1'
? true
: gettext('MTU needs to be >= 576 or 1 to inherit the MTU from the underlying bridge.'),
},
];
if (me.insideWizard) {
me.column1.unshift({
xtype: 'checkbox',
name: 'nonetwork',
inputValue: 'none',
boxLabel: gettext('No network device'),
listeners: {
change: function(cb, value) {
var fields = [
'disconnect',
'bridge',
'tag',
'firewall',
'model',
'macaddr',
'rate',
'queues',
'mtu',
];
fields.forEach(function(fieldname) {
me.down('field[name='+fieldname+']').setDisabled(value);
});
me.down('field[name=bridge]').validate();
},
},
});
me.column2.unshift({
xtype: 'displayfield',
});
}
me.column2.push(
{
xtype: 'pveNetworkCardSelector',
name: 'model',
fieldLabel: gettext('Model'),
bind: '{networkModel}',
value: PVE.qemu.OSDefaults.generic.networkCard,
allowBlank: false,
},
{
xtype: 'textfield',
name: 'macaddr',
fieldLabel: gettext('MAC address'),
vtype: 'MacAddress',
allowBlank: true,
emptyText: 'auto',
});
me.advancedColumn2 = [
{
xtype: 'numberfield',
name: 'rate',
fieldLabel: gettext('Rate limit') + ' (MB/s)',
minValue: 0,
maxValue: 10*1024,
value: '',
emptyText: 'unlimited',
allowBlank: true,
},
{
xtype: 'proxmoxintegerfield',
name: 'queues',
fieldLabel: 'Multiqueue',
minValue: 1,
maxValue: 64,
value: '',
allowBlank: true,
},
];
me.advancedColumnB = [
{
xtype: 'displayfield',
userCls: 'pmx-hint',
value: gettext("Use the special value '1' to inherit the MTU value from the underlying bridge"),
bind: {
hidden: '{!showMtuHint}',
},
},
];
me.callParent();
},
});
Ext.define('PVE.qemu.NetworkEdit', {
extend: 'Proxmox.window.Edit',
isAdd: true,
initComponent: function() {
var me = this;
var nodename = me.pveSelNode.data.node;
if (!nodename) {
throw "no node name specified";
}
me.isCreate = !me.confid;
var ipanel = Ext.create('PVE.qemu.NetworkInputPanel', {
confid: me.confid,
nodename: nodename,
isCreate: me.isCreate,
});
Ext.applyIf(me, {
subject: gettext('Network Device'),
items: ipanel,
});
me.callParent();
me.load({
success: function(response, options) {
var i, confid;
me.vmconfig = response.result.data;
if (!me.isCreate) {
var value = me.vmconfig[me.confid];
var network = PVE.Parser.parseQemuNetwork(me.confid, value);
if (!network) {
Ext.Msg.alert(gettext('Error'), 'Unable to parse network options');
me.close();
return;
}
ipanel.setNetwork(me.confid, network);
} else {
for (i = 0; i < 100; i++) {
confid = 'net' + i.toString();
if (!Ext.isDefined(me.vmconfig[confid])) {
me.confid = confid;
break;
}
}
let ostype = me.vmconfig.ostype;
let defaults = PVE.qemu.OSDefaults.getDefaults(ostype);
let data = {
model: defaults.networkCard,
};
ipanel.setNetwork(me.confid, data);
}
},
});
},
});
/*
* This class holds performance *recommended* settings for the PVE Qemu wizards
* the *mandatory* settings are set in the PVE::QemuServer
* config_to_command sub
* We store this here until we get the data from the API server
*/
// this is how you would add an hypothetic FreeBSD > 10 entry
//
//virtio-blk is stable but virtIO net still
// problematic as of 10.3
// see https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=165059
// addOS({
// parent: 'generic', // inherits defaults
// pveOS: 'freebsd10', // must match a radiofield in OSTypeEdit.js
// busType: 'virtio' // must match a pveBusController value
// // networkCard muss match a pveNetworkCardSelector
Ext.define('PVE.qemu.OSDefaults', {
singleton: true, // will also force creation when loaded
constructor: function() {
let me = this;
let addOS = function(settings) {
if (Object.prototype.hasOwnProperty.call(settings, 'parent')) {
var child = Ext.clone(me[settings.parent]);
me[settings.pveOS] = Ext.apply(child, settings);
} else {
throw "Could not find your genitor";
}
};
// default values
me.generic = {
busType: 'ide',
networkCard: 'e1000',
busPriority: {
ide: 4,
sata: 3,
scsi: 2,
virtio: 1,
},
scsihw: 'virtio-scsi-single',
cputype: 'x86-64-v2-AES',
};
// virtio-net is in kernel since 2.6.25
// virtio-scsi since 3.2 but backported in RHEL with 2.6 kernel
addOS({
pveOS: 'l26',
parent: 'generic',
busType: 'scsi',
busPriority: {
scsi: 4,
virtio: 3,
sata: 2,
ide: 1,
},
networkCard: 'virtio',
});
// recommandation from http://wiki.qemu.org/Windows2000
addOS({
pveOS: 'w2k',
parent: 'generic',
networkCard: 'rtl8139',
scsihw: '',
});
// https://pve.proxmox.com/wiki/Windows_XP_Guest_Notes
addOS({
pveOS: 'wxp',
parent: 'w2k',
});
me.getDefaults = function(ostype) {
if (PVE.qemu.OSDefaults[ostype]) {
return PVE.qemu.OSDefaults[ostype];
} else {
return PVE.qemu.OSDefaults.generic;
}
};
},
});
Ext.define('PVE.qemu.OSTypeInputPanel', {
extend: 'Proxmox.panel.InputPanel',
alias: 'widget.pveQemuOSTypePanel',
onlineHelp: 'qm_os_settings',
insideWizard: false,
controller: {
xclass: 'Ext.app.ViewController',
control: {
'combobox[name=osbase]': {
change: 'onOSBaseChange',
},
'combobox[name=ostype]': {
afterrender: 'onOSTypeChange',
change: 'onOSTypeChange',
},
'checkbox[reference=enableSecondCD]': {
change: 'onSecondCDChange',
},
},
onOSBaseChange: function(field, value) {
let me = this;
me.lookup('ostype').getStore().setData(PVE.Utils.kvm_ostypes[value]);
if (me.getView().insideWizard) {
let isWindows = value === 'Microsoft Windows';
let enableSecondCD = me.lookup('enableSecondCD');
enableSecondCD.setVisible(isWindows);
if (!isWindows) {
enableSecondCD.setValue(false);
}
}
},
onOSTypeChange: function(field) {
var me = this, ostype = field.getValue();
if (!me.getView().insideWizard) {
return;
}
var targetValues = PVE.qemu.OSDefaults.getDefaults(ostype);
me.setWidget('pveBusSelector', targetValues.busType);
me.setWidget('pveNetworkCardSelector', targetValues.networkCard);
me.setWidget('CPUModelSelector', targetValues.cputype);
var scsihw = targetValues.scsihw || '__default__';
this.getViewModel().set('current.scsihw', scsihw);
this.getViewModel().set('current.ostype', ostype);
},
setWidget: function(widget, newValue) {
// changing a widget is safe only if ComponentQuery.query returns us
// a single value array
var widgets = Ext.ComponentQuery.query('pveQemuCreateWizard ' + widget);
if (widgets.length === 1) {
widgets[0].setValue(newValue);
} else {
// ignore multiple disks, we only want to set the type if there is a single disk
}
},
onSecondCDChange: function(widget, value, lastValue) {
let me = this;
let vm = me.getViewModel();
let updateVMConfig = function() {
let widgets = Ext.ComponentQuery.query('pveMultiHDPanel');
if (widgets.length === 1) {
widgets[0].getController().updateVMConfig();
}
};
if (value) {
// only for windows
vm.set('current.ide0', "some");
vm.notify();
updateVMConfig();
me.setWidget('pveBusSelector', 'scsi');
me.setWidget('pveNetworkCardSelector', 'virtio');
} else {
vm.set('current.ide0', "");
vm.notify();
updateVMConfig();
me.setWidget('pveBusSelector', 'scsi');
let ostype = me.lookup('ostype').getValue();
var targetValues = PVE.qemu.OSDefaults.getDefaults(ostype);
me.setWidget('pveBusSelector', targetValues.busType);
}
},
},
setNodename: function(nodename) {
var me = this;
me.lookup('isoSelector').setNodename(nodename);
},
onGetValues: function(values) {
if (values.ide0) {
let drive = {
media: 'cdrom',
file: values.ide0,
};
values.ide0 = PVE.Parser.printQemuDrive(drive);
}
return values;
},
initComponent: function() {
var me = this;
me.items = [
{
xtype: 'displayfield',
value: gettext('Guest OS') + ':',
hidden: !me.insideWizard,
},
{
xtype: 'combobox',
submitValue: false,
name: 'osbase',
fieldLabel: gettext('Type'),
editable: false,
queryMode: 'local',
value: 'Linux',
store: Object.keys(PVE.Utils.kvm_ostypes),
},
{
xtype: 'combobox',
name: 'ostype',
reference: 'ostype',
fieldLabel: gettext('Version'),
value: 'l26',
allowBlank: false,
editable: false,
queryMode: 'local',
valueField: 'val',
displayField: 'desc',
store: {
fields: ['desc', 'val'],
data: PVE.Utils.kvm_ostypes.Linux,
listeners: {
datachanged: function(store) {
var ostype = me.lookup('ostype');
var old_val = ostype.getValue();
if (!me.insideWizard && old_val && store.find('val', old_val) !== -1) {
ostype.setValue(old_val);
} else {
ostype.setValue(store.getAt(0));
}
},
},
},
},
];
if (me.insideWizard) {
me.items.push(
{
xtype: 'proxmoxcheckbox',
reference: 'enableSecondCD',
isFormField: false,
hidden: true,
checked: false,
boxLabel: gettext('Add additional drive for VirtIO drivers'),
listeners: {
change: function(cb, value) {
me.lookup('isoSelector').setDisabled(!value);
me.lookup('isoSelector').setHidden(!value);
},
},
},
{
xtype: 'pveIsoSelector',
reference: 'isoSelector',
name: 'ide0',
nodename: me.nodename,
insideWizard: true,
hidden: true,
disabled: true,
},
);
}
me.callParent();
},
});
Ext.define('PVE.qemu.OSTypeEdit', {
extend: 'Proxmox.window.Edit',
subject: 'OS Type',
items: [{ xtype: 'pveQemuOSTypePanel' }],
initComponent: function() {
var me = this;
me.callParent();
me.load({
success: function(response, options) {
var value = response.result.data.ostype || 'other';
var osinfo = PVE.Utils.get_kvm_osinfo(value);
me.setValues({ ostype: value, osbase: osinfo.base });
},
});
},
});
Ext.define('PVE.qemu.Options', {
extend: 'Proxmox.grid.PendingObjectGrid',
alias: ['widget.PVE.qemu.Options'],
onlineHelp: 'qm_options',
initComponent: function() {
var me = this;
var nodename = me.pveSelNode.data.node;
if (!nodename) {
throw "no node name specified";
}
var vmid = me.pveSelNode.data.vmid;
if (!vmid) {
throw "no VM ID specified";
}
var caps = Ext.state.Manager.get('GuiCap');
var rows = {
name: {
required: true,
defaultValue: me.pveSelNode.data.name,
header: gettext('Name'),
editor: caps.vms['VM.Config.Options'] ? {
xtype: 'proxmoxWindowEdit',
subject: gettext('Name'),
items: {
xtype: 'inputpanel',
items: {
xtype: 'textfield',
name: 'name',
vtype: 'DnsName',
value: '',
fieldLabel: gettext('Name'),
allowBlank: true,
},
onGetValues: function(values) {
var params = values;
if (values.name === undefined ||
values.name === null ||
values.name === '') {
params = { 'delete': 'name' };
}
return params;
},
},
} : undefined,
},
onboot: {
header: gettext('Start at boot'),
defaultValue: '',
renderer: Proxmox.Utils.format_boolean,
editor: caps.vms['VM.Config.Options'] ? {
xtype: 'proxmoxWindowEdit',
subject: gettext('Start at boot'),
items: {
xtype: 'proxmoxcheckbox',
name: 'onboot',
uncheckedValue: 0,
defaultValue: 0,
deleteDefaultValue: true,
fieldLabel: gettext('Start at boot'),
},
} : undefined,
},
startup: {
header: gettext('Start/Shutdown order'),
defaultValue: '',
renderer: PVE.Utils.render_kvm_startup,
editor: caps.vms['VM.Config.Options'] && caps.nodes['Sys.Modify']
? {
xtype: 'pveWindowStartupEdit',
onlineHelp: 'qm_startup_and_shutdown',
} : undefined,
},
ostype: {
header: gettext('OS Type'),
editor: caps.vms['VM.Config.Options'] ? 'PVE.qemu.OSTypeEdit' : undefined,
renderer: PVE.Utils.render_kvm_ostype,
defaultValue: 'other',
},
bootdisk: {
visible: false,
},
boot: {
header: gettext('Boot Order'),
defaultValue: 'cdn',
editor: caps.vms['VM.Config.Disk'] ? 'PVE.qemu.BootOrderEdit' : undefined,
multiKey: ['boot', 'bootdisk'],
renderer: function(order, metaData, record, rowIndex, colIndex, store, pending) {
if (/^\s*$/.test(order)) {
return gettext('(No boot device selected)');
}
let boot = PVE.Parser.parsePropertyString(order, "legacy");
if (boot.order) {
let list = boot.order.split(';');
let ret = '';
list.forEach(dev => {
if (ret) {
ret += ', ';
}
ret += dev;
});
return ret;
}
// legacy style and fallback
let i;
var text = '';
var bootdisk = me.getObjectValue('bootdisk', undefined, pending);
order = boot.legacy || 'cdn';
for (i = 0; i < order.length; i++) {
if (text) {
text += ', ';
}
var sel = order.substring(i, i + 1);
if (sel === 'c') {
if (bootdisk) {
text += bootdisk;
} else {
text += gettext('first disk');
}
} else if (sel === 'n') {
text += gettext('any net');
} else if (sel === 'a') {
text += gettext('Floppy');
} else if (sel === 'd') {
text += gettext('any CD-ROM');
} else {
text += sel;
}
}
return text;
},
},
tablet: {
header: gettext('Use tablet for pointer'),
defaultValue: true,
renderer: Proxmox.Utils.format_boolean,
editor: caps.vms['VM.Config.HWType'] ? {
xtype: 'proxmoxWindowEdit',
subject: gettext('Use tablet for pointer'),
items: {
xtype: 'proxmoxcheckbox',
name: 'tablet',
checked: true,
uncheckedValue: 0,
defaultValue: 1,
deleteDefaultValue: true,
fieldLabel: gettext('Enabled'),
},
} : undefined,
},
hotplug: {
header: gettext('Hotplug'),
defaultValue: 'disk,network,usb',
renderer: PVE.Utils.render_hotplug_features,
editor: caps.vms['VM.Config.HWType'] ? {
xtype: 'proxmoxWindowEdit',
subject: gettext('Hotplug'),
items: {
xtype: 'pveHotplugFeatureSelector',
name: 'hotplug',
value: '',
multiSelect: true,
fieldLabel: gettext('Hotplug'),
allowBlank: true,
},
} : undefined,
},
acpi: {
header: gettext('ACPI support'),
defaultValue: true,
renderer: Proxmox.Utils.format_boolean,
editor: caps.vms['VM.Config.HWType'] ? {
xtype: 'proxmoxWindowEdit',
subject: gettext('ACPI support'),
items: {
xtype: 'proxmoxcheckbox',
name: 'acpi',
checked: true,
uncheckedValue: 0,
defaultValue: 1,
deleteDefaultValue: true,
fieldLabel: gettext('Enabled'),
},
} : undefined,
},
kvm: {
header: gettext('KVM hardware virtualization'),
defaultValue: true,
renderer: Proxmox.Utils.format_boolean,
editor: caps.vms['VM.Config.HWType'] ? {
xtype: 'proxmoxWindowEdit',
subject: gettext('KVM hardware virtualization'),
items: {
xtype: 'proxmoxcheckbox',
name: 'kvm',
checked: true,
uncheckedValue: 0,
defaultValue: 1,
deleteDefaultValue: true,
fieldLabel: gettext('Enabled'),
},
} : undefined,
},
freeze: {
header: gettext('Freeze CPU at startup'),
defaultValue: false,
renderer: Proxmox.Utils.format_boolean,
editor: caps.vms['VM.PowerMgmt'] ? {
xtype: 'proxmoxWindowEdit',
subject: gettext('Freeze CPU at startup'),
items: {
xtype: 'proxmoxcheckbox',
name: 'freeze',
uncheckedValue: 0,
defaultValue: 0,
deleteDefaultValue: true,
labelWidth: 140,
fieldLabel: gettext('Freeze CPU at startup'),
},
} : undefined,
},
localtime: {
header: gettext('Use local time for RTC'),
defaultValue: '__default__',
renderer: PVE.Utils.render_localtime,
editor: caps.vms['VM.Config.Options'] ? {
xtype: 'proxmoxWindowEdit',
subject: gettext('Use local time for RTC'),
width: 400,
items: {
xtype: 'proxmoxKVComboBox',
name: 'localtime',
value: '__default__',
comboItems: [
['__default__', PVE.Utils.render_localtime('__default__')],
[1, PVE.Utils.render_localtime(1)],
[0, PVE.Utils.render_localtime(0)],
],
labelWidth: 140,
fieldLabel: gettext('Use local time for RTC'),
},
} : undefined,
},
startdate: {
header: gettext('RTC start date'),
defaultValue: 'now',
editor: caps.vms['VM.Config.Options'] ? {
xtype: 'proxmoxWindowEdit',
subject: gettext('RTC start date'),
items: {
xtype: 'proxmoxtextfield',
name: 'startdate',
deleteEmpty: true,
value: 'now',
fieldLabel: gettext('RTC start date'),
vtype: 'QemuStartDate',
allowBlank: true,
},
} : undefined,
},
smbios1: {
header: gettext('SMBIOS settings (type1)'),
defaultValue: '',
renderer: Ext.String.htmlEncode,
editor: caps.vms['VM.Config.HWType'] ? 'PVE.qemu.Smbios1Edit' : undefined,
},
agent: {
header: 'QEMU Guest Agent',
defaultValue: false,
renderer: PVE.Utils.render_qga_features,
editor: caps.vms['VM.Config.Options'] ? {
xtype: 'proxmoxWindowEdit',
subject: gettext('Qemu Agent'),
width: 350,
onlineHelp: 'qm_qemu_agent',
items: {
xtype: 'pveAgentFeatureSelector',
name: 'agent',
},
} : undefined,
},
protection: {
header: gettext('Protection'),
defaultValue: false,
renderer: Proxmox.Utils.format_boolean,
editor: caps.vms['VM.Config.Options'] ? {
xtype: 'proxmoxWindowEdit',
subject: gettext('Protection'),
items: {
xtype: 'proxmoxcheckbox',
name: 'protection',
uncheckedValue: 0,
defaultValue: 0,
deleteDefaultValue: true,
fieldLabel: gettext('Enabled'),
},
} : undefined,
},
spice_enhancements: {
header: gettext('Spice Enhancements'),
defaultValue: false,
renderer: PVE.Utils.render_spice_enhancements,
editor: caps.vms['VM.Config.Options'] ? {
xtype: 'proxmoxWindowEdit',
subject: gettext('Spice Enhancements'),
onlineHelp: 'qm_spice_enhancements',
items: {
xtype: 'pveSpiceEnhancementSelector',
name: 'spice_enhancements',
},
} : undefined,
},
vmstatestorage: {
header: gettext('VM State storage'),
defaultValue: '',
renderer: val => val || gettext('Automatic'),
editor: caps.vms['VM.Config.Options'] ? {
xtype: 'proxmoxWindowEdit',
subject: gettext('VM State storage'),
onlineHelp: 'chapter_virtual_machines', // FIXME: use 'qm_vmstatestorage' once available
width: 350,
items: {
xtype: 'pveStorageSelector',
storageContent: 'images',
allowBlank: true,
emptyText: gettext("Automatic (Storage used by the VM, or 'local')"),
autoSelect: false,
deleteEmpty: true,
skipEmptyText: true,
nodename: nodename,
name: 'vmstatestorage',
},
} : undefined,
},
hookscript: {
header: gettext('Hookscript'),
},
};
var baseurl = 'nodes/' + nodename + '/qemu/' + vmid + '/config';
var edit_btn = new Ext.Button({
text: gettext('Edit'),
disabled: true,
handler: function() { me.run_editor(); },
});
var revert_btn = new PVE.button.PendingRevert();
var set_button_status = function() {
var sm = me.getSelectionModel();
var rec = sm.getSelection()[0];
if (!rec) {
edit_btn.disable();
return;
}
var key = rec.data.key;
var pending = rec.data.delete || me.hasPendingChanges(key);
var rowdef = rows[key];
edit_btn.setDisabled(!rowdef.editor);
revert_btn.setDisabled(!pending);
};
Ext.apply(me, {
url: "/api2/json/nodes/" + nodename + "/qemu/" + vmid + "/pending",
interval: 5000,
cwidth1: 250,
tbar: [edit_btn, revert_btn],
rows: rows,
editorConfig: {
url: "/api2/extjs/" + baseurl,
},
listeners: {
itemdblclick: me.run_editor,
selectionchange: set_button_status,
},
});
me.callParent();
me.on('activate', () => me.rstore.startUpdate());
me.on('destroy', () => me.rstore.stopUpdate());
me.on('deactivate', () => me.rstore.stopUpdate());
me.mon(me.getStore(), 'datachanged', function() {
set_button_status();
});
},
});
Ext.define('PVE.qemu.PCIInputPanel', {
extend: 'Proxmox.panel.InputPanel',
onlineHelp: 'qm_pci_passthrough_vm_config',
controller: {
xclass: 'Ext.app.ViewController',
setVMConfig: function(vmconfig) {
let me = this;
let view = me.getView();
me.vmconfig = vmconfig;
let hostpci = me.vmconfig[view.confid] || '';
let values = PVE.Parser.parsePropertyString(hostpci, 'host');
if (values.host) {
if (!values.host.match(/^[0-9a-f]{4}:/i)) { // add optional domain
values.host = "0000:" + values.host;
}
if (values.host.length < 11) { // 0000:00:00 format not 0000:00:00.0
values.host += ".0";
values.multifunction = true;
}
values.type = 'raw';
} else if (values.mapping) {
values.type = 'mapped';
}
values['x-vga'] = PVE.Parser.parseBoolean(values['x-vga'], 0);
values.pcie = PVE.Parser.parseBoolean(values.pcie, 0);
values.rombar = PVE.Parser.parseBoolean(values.rombar, 1);
view.setValues(values);
if (!me.vmconfig.machine || me.vmconfig.machine.indexOf('q35') === -1) {
// machine is not set to some variant of q35, so we disable pcie
let pcie = me.lookup('pcie');
pcie.setDisabled(true);
pcie.setBoxLabel(gettext('Q35 only'));
}
if (values.romfile) {
me.lookup('romfile').setVisible(true);
}
},
selectorEnable: function(selector) {
let me = this;
me.pciDevChange(selector, selector.getValue());
},
pciDevChange: function(pcisel, value) {
let me = this;
let mdevfield = me.lookup('mdev');
if (!value) {
if (!pcisel.isDisabled()) {
mdevfield.setDisabled(true);
}
return;
}
let pciDev = pcisel.getStore().getById(value);
mdevfield.setDisabled(!pciDev || !pciDev.data.mdev);
if (!pciDev) {
return;
}
let path = value;
if (pciDev.data.map) {
// find local mapping
for (const entry of pciDev.data.map) {
let mapping = PVE.Parser.parsePropertyString(entry);
if (mapping.node === pcisel.up('inputpanel').nodename) {
path = mapping.path.split(';')[0];
break;
}
}
if (path.indexOf('.') === -1) {
path += '.0';
}
}
if (pciDev.data.mdev) {
mdevfield.setPciID(path);
}
if (pcisel.reference === 'selector') {
let iommu = pciDev.data.iommugroup;
if (iommu === -1) {
return;
}
// try to find out if there are more devices in that iommu group
let id = path.substring(0, 5); // 00:00
let count = 0;
pcisel.getStore().each(({ data }) => {
if (data.iommugroup === iommu && data.id.substring(0, 5) !== id) {
count++;
return false;
}
return true;
});
me.lookup('group_warning').setVisible(count > 0);
}
},
onGetValues: function(values) {
let me = this;
let view = me.getView();
if (!view.confid) {
for (let i = 0; i < PVE.Utils.hardware_counts.hostpci; i++) {
if (!me.vmconfig['hostpci' + i.toString()]) {
view.confid = 'hostpci' + i.toString();
break;
}
}
// FIXME: what if no confid was found??
}
values.host?.replace(/^0000:/, ''); // remove optional '0000' domain
if (values.multifunction && values.host) {
values.host = values.host.substring(0, values.host.indexOf('.')); // skip the '.X'
delete values.multifunction;
}
if (values.rombar) {
delete values.rombar;
} else {
values.rombar = 0;
}
if (!values.romfile) {
delete values.romfile;
}
delete values.type;
let ret = {};
ret[view.confid] = PVE.Parser.printPropertyString(values, 'host');
return ret;
},
},
viewModel: {
data: {
isMapped: true,
},
},
setVMConfig: function(vmconfig) {
return this.getController().setVMConfig(vmconfig);
},
onGetValues: function(values) {
return this.getController().onGetValues(values);
},
initComponent: function() {
let me = this;
me.nodename = me.pveSelNode.data.node;
if (!me.nodename) {
throw "no node name specified";
}
me.columnT = [
{
xtype: 'displayfield',
reference: 'iommu_warning',
hidden: true,
columnWidth: 1,
padding: '0 0 10 0',
value: 'No IOMMU detected, please activate it.' +
'See Documentation for further information.',
userCls: 'pmx-hint',
},
{
xtype: 'displayfield',
reference: 'group_warning',
hidden: true,
columnWidth: 1,
padding: '0 0 10 0',
itemId: 'iommuwarning',
value: 'The selected Device is not in a seperate IOMMU group, make sure this is intended.',
userCls: 'pmx-hint',
},
];
me.column1 = [
{
xtype: 'radiofield',
name: 'type',
inputValue: 'mapped',
boxLabel: gettext('Mapped Device'),
bind: {
value: '{isMapped}',
},
},
{
xtype: 'pvePCIMapSelector',
fieldLabel: gettext('Device'),
reference: 'mapped_selector',
name: 'mapping',
labelAlign: 'right',
nodename: me.nodename,
allowBlank: false,
bind: {
disabled: '{!isMapped}',
},
listeners: {
change: 'pciDevChange',
enable: 'selectorEnable',
},
},
{
xtype: 'radiofield',
name: 'type',
inputValue: 'raw',
checked: true,
boxLabel: gettext('Raw Device'),
},
{
xtype: 'pvePCISelector',
fieldLabel: gettext('Device'),
name: 'host',
reference: 'selector',
nodename: me.nodename,
labelAlign: 'right',
allowBlank: false,
disabled: true,
bind: {
disabled: '{isMapped}',
},
onLoadCallBack: function(store, records, success) {
if (!success || !records.length) {
return;
}
me.lookup('iommu_warning').setVisible(
records.every((val) => val.data.iommugroup === -1),
);
},
listeners: {
change: 'pciDevChange',
enable: 'selectorEnable',
},
},
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('All Functions'),
reference: 'all_functions',
disabled: true,
labelAlign: 'right',
name: 'multifunction',
bind: {
disabled: '{isMapped}',
},
},
];
me.column2 = [
{
xtype: 'pveMDevSelector',
name: 'mdev',
reference: 'mdev',
disabled: true,
fieldLabel: gettext('MDev Type'),
nodename: me.nodename,
listeners: {
change: function(field, value) {
let multiFunction = me.down('field[name=multifunction]');
if (value) {
multiFunction.setValue(false);
}
multiFunction.setDisabled(!!value);
},
},
},
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Primary GPU'),
name: 'x-vga',
},
];
me.advancedColumn1 = [
{
xtype: 'proxmoxcheckbox',
fieldLabel: 'ROM-Bar',
name: 'rombar',
},
{
xtype: 'displayfield',
submitValue: true,
hidden: true,
fieldLabel: 'ROM-File',
reference: 'romfile',
name: 'romfile',
},
{
xtype: 'textfield',
name: 'vendor-id',
fieldLabel: Ext.String.format(gettext('{0} ID'), gettext('Vendor')),
emptyText: gettext('From Device'),
vtype: 'PciId',
allowBlank: true,
submitEmpty: false,
},
{
xtype: 'textfield',
name: 'device-id',
fieldLabel: Ext.String.format(gettext('{0} ID'), gettext('Device')),
emptyText: gettext('From Device'),
vtype: 'PciId',
allowBlank: true,
submitEmpty: false,
},
];
me.advancedColumn2 = [
{
xtype: 'proxmoxcheckbox',
fieldLabel: 'PCI-Express',
reference: 'pcie',
name: 'pcie',
},
{
xtype: 'textfield',
name: 'sub-vendor-id',
fieldLabel: Ext.String.format(gettext('{0} ID'), gettext('Sub-Vendor')),
emptyText: gettext('From Device'),
vtype: 'PciId',
allowBlank: true,
submitEmpty: false,
},
{
xtype: 'textfield',
name: 'sub-device-id',
fieldLabel: Ext.String.format(gettext('{0} ID'), gettext('Sub-Device')),
emptyText: gettext('From Device'),
vtype: 'PciId',
allowBlank: true,
submitEmpty: false,
},
];
me.callParent();
},
});
Ext.define('PVE.qemu.PCIEdit', {
extend: 'Proxmox.window.Edit',
subject: gettext('PCI Device'),
vmconfig: undefined,
isAdd: true,
initComponent: function() {
let me = this;
me.isCreate = !me.confid;
let ipanel = Ext.create('PVE.qemu.PCIInputPanel', {
confid: me.confid,
pveSelNode: me.pveSelNode,
});
Ext.apply(me, {
items: [ipanel],
});
me.callParent();
me.load({
success: ({ result }) => ipanel.setVMConfig(result.data),
});
},
});
// The view model of the parent shoul contain a 'cgroupMode' variable (or params for v2 are used).
Ext.define('PVE.qemu.ProcessorInputPanel', {
extend: 'Proxmox.panel.InputPanel',
alias: 'widget.pveQemuProcessorPanel',
onlineHelp: 'qm_cpu',
insideWizard: false,
viewModel: {
data: {
socketCount: 1,
coreCount: 1,
showCustomModelPermWarning: false,
userIsRoot: false,
},
formulas: {
totalCoreCount: get => get('socketCount') * get('coreCount'),
cpuunitsDefault: (get) => get('cgroupMode') === 1 ? 1024 : 100,
cpuunitsMin: (get) => get('cgroupMode') === 1 ? 2 : 1,
cpuunitsMax: (get) => get('cgroupMode') === 1 ? 262144 : 10000,
},
},
controller: {
xclass: 'Ext.app.ViewController',
init: function() {
let me = this;
let viewModel = me.getViewModel();
viewModel.set('userIsRoot', Proxmox.UserName === 'root@pam');
},
},
onGetValues: function(values) {
let me = this;
let cpuunitsDefault = me.getViewModel().get('cpuunitsDefault');
if (Array.isArray(values.delete)) {
values.delete = values.delete.join(',');
}
PVE.Utils.delete_if_default(values, 'cpulimit', '0', me.insideWizard);
PVE.Utils.delete_if_default(values, 'cpuunits', `${cpuunitsDefault}`, me.insideWizard);
// build the cpu options:
me.cpu.cputype = values.cputype;
if (values.flags) {
me.cpu.flags = values.flags;
} else {
delete me.cpu.flags;
}
delete values.cputype;
delete values.flags;
var cpustring = PVE.Parser.printQemuCpu(me.cpu);
// remove cputype delete request:
var del = values.delete;
delete values.delete;
if (del) {
del = del.split(',');
Ext.Array.remove(del, 'cputype');
} else {
del = [];
}
if (cpustring) {
values.cpu = cpustring;
} else {
del.push('cpu');
}
var delarr = del.join(',');
if (delarr) {
values.delete = delarr;
}
return values;
},
setValues: function(values) {
let me = this;
let type = values.cputype;
let typeSelector = me.lookupReference('cputype');
let typeStore = typeSelector.getStore();
typeStore.on('load', (store, records, success) => {
if (!success || !type || records.some(x => x.data.name === type)) {
return;
}
// if we get here, a custom CPU model is selected for the VM but we
// don't have permission to configure it - it will not be in the
// list retrieved from the API, so add it manually to allow changing
// other processor options
typeStore.add({
name: type,
displayname: type.replace(/^custom-/, ''),
custom: 1,
vendor: gettext("Unknown"),
});
typeSelector.select(type);
});
me.callParent([values]);
},
cpu: {},
column1: [
{
xtype: 'proxmoxintegerfield',
name: 'sockets',
minValue: 1,
maxValue: 4,
value: '1',
fieldLabel: gettext('Sockets'),
allowBlank: false,
bind: {
value: '{socketCount}',
},
},
{
xtype: 'proxmoxintegerfield',
name: 'cores',
minValue: 1,
maxValue: 128,
value: '1',
fieldLabel: gettext('Cores'),
allowBlank: false,
bind: {
value: '{coreCount}',
},
},
],
column2: [
{
xtype: 'CPUModelSelector',
name: 'cputype',
reference: 'cputype',
fieldLabel: gettext('Type'),
},
{
xtype: 'displayfield',
fieldLabel: gettext('Total cores'),
name: 'totalcores',
isFormField: false,
bind: {
value: '{totalCoreCount}',
},
},
],
columnB: [
{
xtype: 'displayfield',
userCls: 'pmx-hint',
value: gettext('WARNING: You do not have permission to configure custom CPU types, if you change the type you will not be able to go back!'),
hidden: true,
bind: {
hidden: '{!showCustomModelPermWarning}',
},
},
],
advancedColumn1: [
{
xtype: 'proxmoxintegerfield',
name: 'vcpus',
minValue: 1,
maxValue: 1,
value: '',
fieldLabel: gettext('VCPUs'),
deleteEmpty: true,
allowBlank: true,
emptyText: '1',
bind: {
emptyText: '{totalCoreCount}',
maxValue: '{totalCoreCount}',
},
},
{
xtype: 'numberfield',
name: 'cpulimit',
minValue: 0,
maxValue: 128, // api maximum
value: '',
step: 1,
fieldLabel: gettext('CPU limit'),
allowBlank: true,
emptyText: gettext('unlimited'),
},
{
xtype: 'proxmoxtextfield',
name: 'affinity',
vtype: 'CpuSet',
value: '',
fieldLabel: gettext('CPU Affinity'),
allowBlank: true,
emptyText: gettext("All Cores"),
deleteEmpty: true,
bind: {
disabled: '{!userIsRoot}',
},
},
],
advancedColumn2: [
{
xtype: 'proxmoxintegerfield',
name: 'cpuunits',
fieldLabel: gettext('CPU units'),
minValue: '1',
maxValue: '10000',
value: '',
emptyText: '100',
bind: {
minValue: '{cpuunitsMin}',
maxValue: '{cpuunitsMax}',
emptyText: '{cpuunitsDefault}',
},
deleteEmpty: true,
allowBlank: true,
},
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Enable NUMA'),
name: 'numa',
uncheckedValue: 0,
},
],
advancedColumnB: [
{
xtype: 'label',
text: 'Extra CPU Flags:',
},
{
xtype: 'vmcpuflagselector',
name: 'flags',
},
],
});
Ext.define('PVE.qemu.ProcessorEdit', {
extend: 'Proxmox.window.Edit',
alias: 'widget.pveQemuProcessorEdit',
width: 700,
viewModel: {
data: {
cgroupMode: 2,
},
},
initComponent: function() {
let me = this;
me.getViewModel().set('cgroupMode', me.cgroupMode);
var ipanel = Ext.create('PVE.qemu.ProcessorInputPanel');
Ext.apply(me, {
subject: gettext('Processors'),
items: ipanel,
});
me.callParent();
me.load({
success: function(response, options) {
var data = response.result.data;
var value = data.cpu;
if (value) {
var cpu = PVE.Parser.parseQemuCpu(value);
ipanel.cpu = cpu;
data.cputype = cpu.cputype;
if (cpu.flags) {
data.flags = cpu.flags;
}
let caps = Ext.state.Manager.get('GuiCap');
if (data.cputype.indexOf('custom-') === 0 &&
!caps.nodes['Sys.Audit']) {
let vm = ipanel.getViewModel();
vm.set("showCustomModelPermWarning", true);
}
}
me.setValues(data);
},
});
},
});
Ext.define('PVE.qemu.BiosEdit', {
extend: 'Proxmox.window.Edit',
alias: 'widget.pveQemuBiosEdit',
onlineHelp: 'qm_bios_and_uefi',
subject: 'BIOS',
autoLoad: true,
viewModel: {
data: {
bios: '__default__',
efidisk0: false,
},
formulas: {
showEFIDiskHint: (get) => get('bios') === 'ovmf' && !get('efidisk0'),
},
},
items: [
{
xtype: 'pveQemuBiosSelector',
onlineHelp: 'qm_bios_and_uefi',
name: 'bios',
value: '__default__',
bind: '{bios}',
fieldLabel: 'BIOS',
},
{
xtype: 'displayfield',
name: 'efidisk0',
bind: '{efidisk0}',
hidden: true,
},
{
xtype: 'displayfield',
userCls: 'pmx-hint',
value: gettext('You need to add an EFI disk for storing the EFI settings. See the online help for details.'),
bind: {
hidden: '{!showEFIDiskHint}',
},
},
],
});
Ext.define('PVE.qemu.RNGInputPanel', {
extend: 'Proxmox.panel.InputPanel',
xtype: 'pveRNGInputPanel',
onlineHelp: 'qm_virtio_rng',
onGetValues: function(values) {
if (values.max_bytes === "") {
values.max_bytes = "0";
} else if (values.max_bytes === "1024" && values.period === "") {
delete values.max_bytes;
}
var ret = PVE.Parser.printPropertyString(values);
return {
rng0: ret,
};
},
setValues: function(values) {
if (values.max_bytes === 0) {
values.max_bytes = null;
}
this.callParent(arguments);
},
controller: {
xclass: 'Ext.app.ViewController',
control: {
'#max_bytes': {
change: function(el, newVal) {
let limitWarning = this.lookupReference('limitWarning');
limitWarning.setHidden(!!newVal);
},
},
'#source': {
change: function(el, newVal) {
let limitWarning = this.lookupReference('sourceWarning');
limitWarning.setHidden(newVal !== '/dev/random');
},
},
},
},
items: [{
itemId: 'source',
name: 'source',
xtype: 'proxmoxKVComboBox',
value: '/dev/urandom',
fieldLabel: gettext('Entropy source'),
labelWidth: 130,
comboItems: [
['/dev/urandom', '/dev/urandom'],
['/dev/random', '/dev/random'],
['/dev/hwrng', '/dev/hwrng'],
],
},
{
xtype: 'numberfield',
itemId: 'max_bytes',
name: 'max_bytes',
minValue: 0,
step: 1,
value: 1024,
fieldLabel: gettext('Limit (Bytes/Period)'),
labelWidth: 130,
emptyText: gettext('unlimited'),
},
{
xtype: 'numberfield',
name: 'period',
minValue: 1,
step: 1,
fieldLabel: gettext('Period') + ' (ms)',
labelWidth: 130,
emptyText: '1000',
},
{
xtype: 'displayfield',
reference: 'sourceWarning',
value: gettext('Using /dev/random as entropy source is discouraged, as it can lead to host entropy starvation. /dev/urandom is preferred, and does not lead to a decrease in security in practice.'),
userCls: 'pmx-hint',
hidden: true,
},
{
xtype: 'displayfield',
reference: 'limitWarning',
value: gettext('Disabling the limiter can potentially allow a guest to overload the host. Proceed with caution.'),
userCls: 'pmx-hint',
hidden: true,
}],
});
Ext.define('PVE.qemu.RNGEdit', {
extend: 'Proxmox.window.Edit',
subject: gettext('VirtIO RNG'),
items: [{
xtype: 'pveRNGInputPanel',
}],
initComponent: function() {
var me = this;
me.callParent();
if (!me.isCreate) {
me.load({
success: function(response) {
me.vmconfig = response.result.data;
var rng0 = me.vmconfig.rng0;
if (rng0) {
me.setValues(PVE.Parser.parsePropertyString(rng0));
}
},
});
}
},
});
Ext.define('PVE.qemu.SSHKeyInputPanel', {
extend: 'Proxmox.panel.InputPanel',
xtype: 'pveQemuSSHKeyInputPanel',
insideWizard: false,
onGetValues: function(values) {
var me = this;
if (values.sshkeys) {
values.sshkeys.trim();
}
if (!values.sshkeys.length) {
values = {};
values.delete = 'sshkeys';
return values;
} else {
values.sshkeys = encodeURIComponent(values.sshkeys);
}
return values;
},
items: [
{
xtype: 'textarea',
itemId: 'sshkeys',
name: 'sshkeys',
height: 250,
},
{
xtype: 'filebutton',
itemId: 'filebutton',
name: 'file',
text: gettext('Load SSH Key File'),
fieldLabel: 'test',
listeners: {
change: function(btn, e, value) {
let view = this.up('inputpanel');
e = e.event;
Ext.Array.each(e.target.files, function(file) {
PVE.Utils.loadSSHKeyFromFile(file, function(res) {
let keysField = view.down('#sshkeys');
var old = keysField.getValue();
keysField.setValue(old + res);
});
});
btn.reset();
},
},
},
],
initComponent: function() {
var me = this;
me.callParent();
if (!window.FileReader) {
me.down('#filebutton').setVisible(false);
}
},
});
Ext.define('PVE.qemu.SSHKeyEdit', {
extend: 'Proxmox.window.Edit',
width: 800,
initComponent: function() {
var me = this;
var ipanel = Ext.create('PVE.qemu.SSHKeyInputPanel');
Ext.apply(me, {
subject: gettext('SSH Keys'),
items: [ipanel],
});
me.callParent();
if (!me.create) {
me.load({
success: function(response, options) {
var data = response.result.data;
if (data.sshkeys) {
data.sshkeys = decodeURIComponent(data.sshkeys);
ipanel.setValues(data);
}
},
});
}
},
});
Ext.define('PVE.qemu.ScsiHwEdit', {
extend: 'Proxmox.window.Edit',
initComponent: function() {
var me = this;
Ext.applyIf(me, {
subject: gettext('SCSI Controller Type'),
items: {
xtype: 'pveScsiHwSelector',
name: 'scsihw',
value: '__default__',
fieldLabel: gettext('Type'),
},
});
me.callParent();
me.load();
},
});
Ext.define('PVE.qemu.SerialnputPanel', {
extend: 'Proxmox.panel.InputPanel',
autoComplete: false,
setVMConfig: function(vmconfig) {
var me = this, i;
me.vmconfig = vmconfig;
for (i = 0; i < 4; i++) {
var port = 'serial' + i.toString();
if (!me.vmconfig[port]) {
me.down('field[name=serialid]').setValue(i);
break;
}
}
},
onGetValues: function(values) {
var me = this;
var id = 'serial' + values.serialid;
delete values.serialid;
values[id] = 'socket';
return values;
},
items: [
{
xtype: 'proxmoxintegerfield',
name: 'serialid',
fieldLabel: gettext('Serial Port'),
minValue: 0,
maxValue: 3,
allowBlank: false,
validator: function(id) {
if (!this.rendered) {
return true;
}
let view = this.up('panel');
if (view.vmconfig !== undefined && Ext.isDefined(view.vmconfig['serial' + id])) {
return "This device is already in use.";
}
return true;
},
},
],
});
Ext.define('PVE.qemu.SerialEdit', {
extend: 'Proxmox.window.Edit',
vmconfig: undefined,
isAdd: true,
subject: gettext('Serial Port'),
initComponent: function() {
var me = this;
// for now create of (socket) serial port only
me.isCreate = true;
var ipanel = Ext.create('PVE.qemu.SerialnputPanel', {});
Ext.apply(me, {
items: [ipanel],
});
me.callParent();
me.load({
success: function(response, options) {
ipanel.setVMConfig(response.result.data);
},
});
},
});
Ext.define('PVE.qemu.Smbios1InputPanel', {
extend: 'Proxmox.panel.InputPanel',
alias: 'widget.PVE.qemu.Smbios1InputPanel',
insideWizard: false,
smbios1: {},
onGetValues: function(values) {
var me = this;
var params = {
smbios1: PVE.Parser.printQemuSmbios1(values),
};
return params;
},
setSmbios1: function(data) {
var me = this;
me.smbios1 = data;
me.setValues(me.smbios1);
},
items: [
{
xtype: 'textfield',
fieldLabel: 'UUID',
regex: /^[a-fA-F0-9]{8}(?:-[a-fA-F0-9]{4}){3}-[a-fA-F0-9]{12}$/,
name: 'uuid',
},
{
xtype: 'textareafield',
fieldLabel: gettext('Manufacturer'),
fieldStyle: {
height: '2em',
minHeight: '2em',
},
name: 'manufacturer',
},
{
xtype: 'textareafield',
fieldLabel: gettext('Product'),
fieldStyle: {
height: '2em',
minHeight: '2em',
},
name: 'product',
},
{
xtype: 'textareafield',
fieldLabel: gettext('Version'),
fieldStyle: {
height: '2em',
minHeight: '2em',
},
name: 'version',
},
{
xtype: 'textareafield',
fieldLabel: gettext('Serial'),
fieldStyle: {
height: '2em',
minHeight: '2em',
},
name: 'serial',
},
{
xtype: 'textareafield',
fieldLabel: 'SKU',
fieldStyle: {
height: '2em',
minHeight: '2em',
},
name: 'sku',
},
{
xtype: 'textareafield',
fieldLabel: gettext('Family'),
fieldStyle: {
height: '2em',
minHeight: '2em',
},
name: 'family',
},
],
});
Ext.define('PVE.qemu.Smbios1Edit', {
extend: 'Proxmox.window.Edit',
initComponent: function() {
var me = this;
var ipanel = Ext.create('PVE.qemu.Smbios1InputPanel', {});
Ext.applyIf(me, {
subject: gettext('SMBIOS settings (type1)'),
width: 450,
items: ipanel,
});
me.callParent();
me.load({
success: function(response, options) {
me.vmconfig = response.result.data;
var value = me.vmconfig.smbios1;
if (value) {
var data = PVE.Parser.parseQemuSmbios1(value);
if (!data) {
Ext.Msg.alert(gettext('Error'), 'Unable to parse smbios options');
me.close();
return;
}
ipanel.setSmbios1(data);
}
},
});
},
});
Ext.define('PVE.qemu.SystemInputPanel', {
extend: 'Proxmox.panel.InputPanel',
xtype: 'pveQemuSystemPanel',
onlineHelp: 'qm_system_settings',
viewModel: {
data: {
efi: false,
addefi: true,
},
formulas: {
efidisk: function(get) {
return get('efi') && get('addefi');
},
},
},
onGetValues: function(values) {
if (values.vga && values.vga.substr(0, 6) === 'serial') {
values['serial' + values.vga.substr(6, 1)] = 'socket';
}
delete values.hdimage;
delete values.hdstorage;
delete values.diskformat;
delete values.preEnrolledKeys; // efidisk
delete values.version; // tpmstate
return values;
},
controller: {
xclass: 'Ext.app.ViewController',
scsihwChange: function(field, value) {
var me = this;
if (me.getView().insideWizard) {
me.getViewModel().set('current.scsihw', value);
}
},
biosChange: function(field, value) {
var me = this;
if (me.getView().insideWizard) {
me.getViewModel().set('efi', value === 'ovmf');
}
},
control: {
'pveScsiHwSelector': {
change: 'scsihwChange',
},
'pveQemuBiosSelector': {
change: 'biosChange',
},
'#': {
afterrender: 'setMachine',
},
},
setMachine: function() {
let me = this;
let vm = this.getViewModel();
let ostype = vm.get('current.ostype');
if (ostype === 'win11') {
me.lookup('machine').setValue('q35');
me.lookup('bios').setValue('ovmf');
me.lookup('addtpmbox').setValue(true);
}
},
},
column1: [
{
xtype: 'proxmoxKVComboBox',
value: '__default__',
deleteEmpty: false,
fieldLabel: gettext('Graphic card'),
name: 'vga',
comboItems: Object.entries(PVE.Utils.kvm_vga_drivers),
},
{
xtype: 'proxmoxKVComboBox',
name: 'machine',
reference: 'machine',
value: '__default__',
fieldLabel: gettext('Machine'),
comboItems: [
['__default__', PVE.Utils.render_qemu_machine('')],
['q35', 'q35'],
],
},
{
xtype: 'displayfield',
value: gettext('Firmware'),
},
{
xtype: 'pveQemuBiosSelector',
name: 'bios',
reference: 'bios',
value: '__default__',
fieldLabel: 'BIOS',
},
{
xtype: 'proxmoxcheckbox',
bind: {
value: '{addefi}',
hidden: '{!efi}',
disabled: '{!efi}',
},
hidden: true,
submitValue: false,
disabled: true,
fieldLabel: gettext('Add EFI Disk'),
},
{
xtype: 'pveEFIDiskInputPanel',
name: 'efidisk0',
storageContent: 'images',
bind: {
nodename: '{nodename}',
hidden: '{!efi}',
disabled: '{!efidisk}',
},
autoSelect: false,
disabled: true,
hidden: true,
hideSize: true,
usesEFI: true,
},
],
column2: [
{
xtype: 'pveScsiHwSelector',
name: 'scsihw',
value: '__default__',
bind: {
value: '{current.scsihw}',
},
fieldLabel: gettext('SCSI Controller'),
},
{
xtype: 'proxmoxcheckbox',
name: 'agent',
uncheckedValue: 0,
defaultValue: 0,
deleteDefaultValue: true,
fieldLabel: gettext('Qemu Agent'),
},
{
// fake for spacing
xtype: 'displayfield',
value: ' ',
},
{
xtype: 'proxmoxcheckbox',
reference: 'addtpmbox',
bind: {
value: '{addtpm}',
},
submitValue: false,
fieldLabel: gettext('Add TPM'),
},
{
xtype: 'pveTPMDiskInputPanel',
name: 'tpmstate0',
storageContent: 'images',
bind: {
nodename: '{nodename}',
hidden: '{!addtpm}',
disabled: '{!addtpm}',
},
disabled: true,
hidden: true,
},
],
});
Ext.define('PVE.qemu.USBInputPanel', {
extend: 'Proxmox.panel.InputPanel',
mixins: ['Proxmox.Mixin.CBind'],
autoComplete: false,
onlineHelp: 'qm_usb_passthrough',
cbindData: function(initialConfig) {
let me = this;
if (!me.pveSelNode) {
throw "no pveSelNode given";
}
return { nodename: me.pveSelNode.data.node };
},
viewModel: {
data: {},
},
setVMConfig: function(vmconfig) {
var me = this;
me.vmconfig = vmconfig;
let max_usb = PVE.Utils.get_max_usb_count(me.vmconfig.ostype, me.vmconfig.machine);
if (max_usb > PVE.Utils.hardware_counts.usb_old) {
me.down('field[name=usb3]').setDisabled(true);
}
},
onGetValues: function(values) {
var me = this;
if (!me.confid) {
let max_usb = PVE.Utils.get_max_usb_count(me.vmconfig.ostype, me.vmconfig.machine);
for (let i = 0; i < max_usb; i++) {
let id = 'usb' + i.toString();
if (!me.vmconfig[id]) {
me.confid = id;
break;
}
}
}
var val = "";
var type = me.down('radiofield').getGroupValue();
switch (type) {
case 'spice':
val = 'spice';
break;
case 'mapped':
val = `mapping=${values[type]}`;
delete values.mapped;
break;
case 'hostdevice':
case 'port':
val = 'host=' + values[type];
delete values[type];
break;
default:
throw "invalid type selected";
}
if (values.usb3) {
delete values.usb3;
val += ',usb3=1';
}
values[me.confid] = val;
return values;
},
items: [
{
xtype: 'fieldcontainer',
defaultType: 'radiofield',
layout: 'fit',
items: [
{
name: 'usb',
inputValue: 'spice',
boxLabel: gettext('Spice Port'),
submitValue: false,
checked: true,
},
{
name: 'usb',
inputValue: 'mapped',
boxLabel: gettext('Use mapped Device'),
reference: 'mapped',
submitValue: false,
},
{
xtype: 'pveUSBMapSelector',
disabled: true,
name: 'mapped',
cbind: { nodename: '{nodename}' },
bind: { disabled: '{!mapped.checked}' },
allowBlank: false,
fieldLabel: gettext('Choose Device'),
labelAlign: 'right',
},
{
name: 'usb',
inputValue: 'hostdevice',
boxLabel: gettext('Use USB Vendor/Device ID'),
reference: 'hostdevice',
submitValue: false,
},
{
xtype: 'pveUSBSelector',
disabled: true,
type: 'device',
name: 'hostdevice',
cbind: { pveSelNode: '{pveSelNode}' },
bind: { disabled: '{!hostdevice.checked}' },
editable: true,
allowBlank: false,
fieldLabel: gettext('Choose Device'),
labelAlign: 'right',
},
{
name: 'usb',
inputValue: 'port',
boxLabel: gettext('Use USB Port'),
reference: 'port',
submitValue: false,
},
{
xtype: 'pveUSBSelector',
disabled: true,
name: 'port',
cbind: { pveSelNode: '{pveSelNode}' },
bind: { disabled: '{!port.checked}' },
editable: true,
type: 'port',
allowBlank: false,
fieldLabel: gettext('Choose Port'),
labelAlign: 'right',
},
{
xtype: 'checkbox',
name: 'usb3',
inputValue: true,
checked: true,
reference: 'usb3',
fieldLabel: gettext('Use USB3'),
},
],
},
],
});
Ext.define('PVE.qemu.USBEdit', {
extend: 'Proxmox.window.Edit',
vmconfig: undefined,
isAdd: true,
width: 400,
subject: gettext('USB Device'),
initComponent: function() {
var me = this;
me.isCreate = !me.confid;
var ipanel = Ext.create('PVE.qemu.USBInputPanel', {
confid: me.confid,
pveSelNode: me.pveSelNode,
});
Ext.apply(me, {
items: [ipanel],
});
me.callParent();
me.load({
success: function(response, options) {
ipanel.setVMConfig(response.result.data);
if (me.isCreate) {
return;
}
let data = PVE.Parser.parsePropertyString(response.result.data[me.confid], 'host');
let port, hostdevice, mapped, usb3 = false;
let usb;
if (data.host) {
if (/^(0x)?[a-zA-Z0-9]{4}:(0x)?[a-zA-Z0-9]{4}$/.test(data.host)) {
hostdevice = data.host.replace('0x', '');
usb = 'hostdevice';
} else if (/^(\d+)-(\d+(\.\d+)*)$/.test(data.host)) {
port = data.host;
usb = 'port';
} else if (/^spice$/i.test(data.host)) {
usb = 'spice';
}
} else if (data.mapping) {
mapped = data.mapping;
usb = 'mapped';
}
usb3 = data.usb3 ?? false;
var values = {
usb,
hostdevice,
port,
usb3,
mapped,
};
ipanel.setValues(values);
},
});
},
});
Ext.define('PVE.sdn.Browser', {
extend: 'PVE.panel.Config',
alias: 'widget.PVE.sdn.Browser',
onlineHelp: 'chapter_pvesdn',
initComponent: function() {
let me = this;
let nodename = me.pveSelNode.data.node;
if (!nodename) {
throw "no node name specified";
}
let sdnId = me.pveSelNode.data.sdn;
if (!sdnId) {
throw "no sdn ID specified";
}
me.items = [];
Ext.apply(me, {
title: Ext.String.format(gettext("Zone {0} on node {1}"), `'${sdnId}'`, `'${nodename}'`),
hstateid: 'sdntab',
});
const caps = Ext.state.Manager.get('GuiCap');
me.items.push({
nodename: nodename,
zone: sdnId,
xtype: 'pveSDNZoneContentPanel',
title: gettext('Content'),
iconCls: 'fa fa-th',
itemId: 'content',
});
if (caps.sdn['Permissions.Modify']) {
me.items.push({
xtype: 'pveACLView',
title: gettext('Permissions'),
iconCls: 'fa fa-unlock',
itemId: 'permissions',
path: `/sdn/zones/${sdnId}`,
});
}
me.callParent();
},
});
Ext.define('PVE.sdn.ControllerView', {
extend: 'Ext.grid.GridPanel',
alias: ['widget.pveSDNControllerView'],
onlineHelp: 'pvesdn_config_controllers',
stateful: true,
stateId: 'grid-sdn-controller',
createSDNControllerEditWindow: function(type, sid) {
var schema = PVE.Utils.sdncontrollerSchema[type];
if (!schema || !schema.ipanel) {
throw "no editor registered for controller type: " + type;
}
Ext.create('PVE.sdn.controllers.BaseEdit', {
paneltype: 'PVE.sdn.controllers.' + schema.ipanel,
type: type,
controllerid: sid,
autoShow: true,
listeners: {
destroy: this.reloadStore,
},
});
},
initComponent: function() {
var me = this;
var store = new Ext.data.Store({
model: 'pve-sdn-controller',
proxy: {
type: 'proxmox',
url: "/api2/json/cluster/sdn/controllers?pending=1",
},
sorters: {
property: 'controller',
direction: 'ASC',
},
});
let sm = Ext.create('Ext.selection.RowModel', {});
let run_editor = function() {
let rec = sm.getSelection()[0];
if (!rec) {
return;
}
let type = rec.data.type, controller = rec.data.controller;
me.createSDNControllerEditWindow(type, controller);
};
let edit_btn = new Proxmox.button.Button({
text: gettext('Edit'),
disabled: true,
selModel: sm,
handler: run_editor,
});
let remove_btn = Ext.create('Proxmox.button.StdRemoveButton', {
selModel: sm,
baseurl: '/cluster/sdn/controllers/',
callback: () => store.load(),
});
// else we cannot dynamically generate the add menu handlers
let addHandleGenerator = function(type) {
return function() { me.createSDNControllerEditWindow(type); };
};
let addMenuItems = [];
for (const [type, controller] of Object.entries(PVE.Utils.sdncontrollerSchema)) {
if (controller.hideAdd) {
continue;
}
addMenuItems.push({
text: PVE.Utils.format_sdncontroller_type(type),
iconCls: 'fa fa-fw fa-' + controller.faIcon,
handler: addHandleGenerator(type),
});
}
Ext.apply(me, {
store: store,
reloadStore: () => store.load(),
selModel: sm,
viewConfig: {
trackOver: false,
},
tbar: [
{
text: gettext('Add'),
menu: new Ext.menu.Menu({
items: addMenuItems,
}),
},
remove_btn,
edit_btn,
],
columns: [
{
header: 'ID',
flex: 2,
sortable: true,
dataIndex: 'controller',
renderer: function(value, metaData, rec) {
return PVE.Utils.render_sdn_pending(rec, value, 'controller', 1);
},
},
{
header: gettext('Type'),
flex: 1,
sortable: true,
dataIndex: 'type',
renderer: function(value, metaData, rec) {
return PVE.Utils.render_sdn_pending(rec, value, 'type', 1);
},
},
{
header: gettext('Node'),
flex: 1,
sortable: true,
dataIndex: 'node',
renderer: function(value, metaData, rec) {
return PVE.Utils.render_sdn_pending(rec, value, 'node', 1);
},
},
{
header: gettext('State'),
width: 100,
dataIndex: 'state',
renderer: function(value, metaData, rec) {
return PVE.Utils.render_sdn_pending_state(rec, value);
},
},
],
listeners: {
activate: () => store.load(),
itemdblclick: run_editor,
},
});
store.load();
me.callParent();
},
});
Ext.define('PVE.sdn.Status', {
extend: 'Ext.panel.Panel',
alias: 'widget.pveSDNStatus',
onlineHelp: 'chapter_pvesdn',
layout: {
type: 'vbox',
align: 'stretch',
},
initComponent: function() {
var me = this;
me.rstore = Ext.create('Proxmox.data.ObjectStore', {
interval: me.interval,
model: 'pve-sdn-status',
storeid: 'pve-store-' + ++Ext.idSeed,
groupField: 'type',
proxy: {
type: 'proxmox',
url: '/api2/json/cluster/resources',
},
});
me.items = [{
xtype: 'pveSDNStatusView',
title: gettext('Status'),
rstore: me.rstore,
border: 0,
collapsible: true,
padding: '0 0 20 0',
}];
me.callParent();
me.on('activate', me.rstore.startUpdate);
},
});
Ext.define('PVE.sdn.StatusView', {
extend: 'Ext.grid.GridPanel',
alias: 'widget.pveSDNStatusView',
sortPriority: {
sdn: 1,
node: 2,
status: 3,
},
initComponent: function() {
var me = this;
if (!me.rstore) {
throw "no rstore given";
}
Proxmox.Utils.monStoreErrors(me, me.rstore);
var store = Ext.create('Proxmox.data.DiffStore', {
rstore: me.rstore,
sortAfterUpdate: true,
sorters: [{
sorterFn: function(rec1, rec2) {
var p1 = me.sortPriority[rec1.data.type];
var p2 = me.sortPriority[rec2.data.type];
return p1 !== p2 ? p1 > p2 ? 1 : -1 : 0;
},
}],
filters: {
property: 'type',
value: 'sdn',
operator: '==',
},
});
Ext.apply(me, {
store: store,
stateful: false,
tbar: [
{
text: gettext('Apply'),
handler: function() {
Proxmox.Utils.API2Request({
url: '/cluster/sdn/',
method: 'PUT',
waitMsgTarget: me,
failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
},
});
},
},
],
viewConfig: {
trackOver: false,
},
columns: [
{
header: 'SDN',
width: 80,
dataIndex: 'sdn',
},
{
header: gettext('Node'),
width: 80,
dataIndex: 'node',
},
{
header: gettext('Status'),
width: 80,
flex: 1,
dataIndex: 'status',
},
],
});
me.callParent();
me.on('activate', me.rstore.startUpdate);
me.on('destroy', me.rstore.stopUpdate);
},
}, function() {
Ext.define('pve-sdn-status', {
extend: 'Ext.data.Model',
fields: [
'id', 'type', 'node', 'status', 'sdn',
],
idProperty: 'id',
});
});
Ext.define('PVE.sdn.VnetInputPanel', {
extend: 'Proxmox.panel.InputPanel',
mixins: ['Proxmox.Mixin.CBind'],
onGetValues: function(values) {
let me = this;
if (me.isCreate) {
values.type = 'vnet';
}
return values;
},
items: [
{
xtype: 'pmxDisplayEditField',
name: 'vnet',
cbind: {
editable: '{isCreate}',
},
maxLength: 8,
flex: 1,
allowBlank: false,
fieldLabel: gettext('Name'),
},
{
xtype: 'proxmoxtextfield',
name: 'alias',
fieldLabel: gettext('Alias'),
allowBlank: true,
skipEmptyText: true,
cbind: {
deleteEmpty: "{!isCreate}",
},
},
{
xtype: 'pveSDNZoneSelector',
fieldLabel: gettext('Zone'),
name: 'zone',
value: '',
allowBlank: false,
},
{
xtype: 'proxmoxintegerfield',
name: 'tag',
minValue: 1,
maxValue: 16777216,
fieldLabel: gettext('Tag'),
allowBlank: true,
cbind: {
deleteEmpty: "{!isCreate}",
},
},
{
xtype: 'proxmoxcheckbox',
name: 'vlanaware',
uncheckedValue: null,
checked: false,
fieldLabel: gettext('VLAN Aware'),
cbind: {
deleteEmpty: "{!isCreate}",
},
},
],
});
Ext.define('PVE.sdn.VnetEdit', {
extend: 'Proxmox.window.Edit',
subject: gettext('VNet'),
vnet: undefined,
width: 350,
initComponent: function() {
var me = this;
me.isCreate = me.vnet === undefined;
if (me.isCreate) {
me.url = '/api2/extjs/cluster/sdn/vnets';
me.method = 'POST';
} else {
me.url = '/api2/extjs/cluster/sdn/vnets/' + me.vnet;
me.method = 'PUT';
}
let ipanel = Ext.create('PVE.sdn.VnetInputPanel', {
isCreate: me.isCreate,
});
Ext.apply(me, {
items: [
ipanel,
],
});
me.callParent();
if (!me.isCreate) {
me.load({
success: function(response, options) {
let values = response.result.data;
ipanel.setValues(values);
},
});
}
},
});
Ext.define('PVE.sdn.VnetView', {
extend: 'Ext.grid.GridPanel',
alias: 'widget.pveSDNVnetView',
onlineHelp: 'pvesdn_config_vnet',
stateful: true,
stateId: 'grid-sdn-vnet',
subnetview_panel: undefined,
initComponent: function() {
let me = this;
let store = new Ext.data.Store({
model: 'pve-sdn-vnet',
proxy: {
type: 'proxmox',
url: "/api2/json/cluster/sdn/vnets?pending=1",
},
sorters: {
property: 'vnet',
direction: 'ASC',
},
});
let reload = () => store.load();
let sm = Ext.create('Ext.selection.RowModel', {});
let run_editor = function() {
let rec = sm.getSelection()[0];
let win = Ext.create('PVE.sdn.VnetEdit', {
autoShow: true,
onlineHelp: 'pvesdn_config_vnet',
vnet: rec.data.vnet,
});
win.on('destroy', reload);
};
let edit_btn = new Proxmox.button.Button({
text: gettext('Edit'),
disabled: true,
selModel: sm,
handler: run_editor,
});
let remove_btn = Ext.create('Proxmox.button.StdRemoveButton', {
selModel: sm,
baseurl: '/cluster/sdn/vnets/',
callback: reload,
});
let set_button_status = function() {
var rec = me.selModel.getSelection()[0];
if (!rec || rec.data.state === 'deleted') {
edit_btn.disable();
remove_btn.disable();
}
};
Ext.apply(me, {
store: store,
reloadStore: reload,
selModel: sm,
viewConfig: {
trackOver: false,
},
tbar: [
{
text: gettext('Create'),
handler: function() {
let win = Ext.create('PVE.sdn.VnetEdit', {
autoShow: true,
onlineHelp: 'pvesdn_config_vnet',
type: 'vnet',
});
win.on('destroy', reload);
},
},
remove_btn,
edit_btn,
],
columns: [
{
header: 'ID',
flex: 2,
dataIndex: 'vnet',
renderer: function(value, metaData, rec) {
return PVE.Utils.render_sdn_pending(rec, value, 'vnet', 1);
},
},
{
header: gettext('Alias'),
flex: 1,
dataIndex: 'alias',
renderer: function(value, metaData, rec) {
return PVE.Utils.render_sdn_pending(rec, value, 'alias');
},
},
{
header: gettext('Zone'),
flex: 1,
dataIndex: 'zone',
renderer: function(value, metaData, rec) {
return PVE.Utils.render_sdn_pending(rec, value, 'zone');
},
},
{
header: gettext('Tag'),
flex: 1,
dataIndex: 'tag',
renderer: function(value, metaData, rec) {
return PVE.Utils.render_sdn_pending(rec, value, 'tag');
},
},
{
header: gettext('VLAN Aware'),
flex: 1,
dataIndex: 'vlanaware',
renderer: function(value, metaData, rec) {
return PVE.Utils.render_sdn_pending(rec, value, 'vlanaware');
},
},
{
header: gettext('State'),
width: 100,
dataIndex: 'state',
renderer: function(value, metaData, rec) {
return PVE.Utils.render_sdn_pending_state(rec, value);
},
},
],
listeners: {
activate: reload,
itemdblclick: run_editor,
selectionchange: set_button_status,
show: reload,
select: function(_sm, rec) {
let url = `/cluster/sdn/vnets/${rec.data.vnet}/subnets`;
me.subnetview_panel.setBaseUrl(url);
},
deselect: function() {
me.subnetview_panel.setBaseUrl(undefined);
},
},
});
store.load();
me.callParent();
},
});
Ext.define('PVE.sdn.VnetACLAdd', {
extend: 'Proxmox.window.Edit',
alias: ['widget.pveSDNVnetACLAdd'],
url: '/access/acl',
method: 'PUT',
isAdd: true,
isCreate: true,
width: 400,
initComponent: function() {
let me = this;
let items = [
{
xtype: 'hiddenfield',
name: 'path',
value: me.path,
allowBlank: false,
fieldLabel: gettext('Path'),
},
];
if (me.aclType === 'group') {
me.subject = gettext("Group Permission");
items.push({
xtype: 'pveGroupSelector',
name: 'groups',
fieldLabel: gettext('Group'),
});
} else if (me.aclType === 'user') {
me.subject = gettext("User Permission");
items.push({
xtype: 'pmxUserSelector',
name: 'users',
fieldLabel: gettext('User'),
});
} else if (me.aclType === 'token') {
me.subject = gettext("API Token Permission");
items.push({
xtype: 'pveTokenSelector',
name: 'tokens',
fieldLabel: gettext('API Token'),
});
} else {
throw "unknown ACL type";
}
items.push({
xtype: 'pmxRoleSelector',
name: 'roles',
value: 'NoAccess',
fieldLabel: gettext('Role'),
});
items.push({
xtype: 'proxmoxintegerfield',
name: 'vlan',
minValue: 1,
maxValue: 4096,
allowBlank: true,
fieldLabel: 'VLAN',
emptyText: gettext('All'),
});
let ipanel = Ext.create('Proxmox.panel.InputPanel', {
items: items,
onlineHelp: 'pveum_permission_management',
onGetValues: function(values) {
if (values.vlan) {
values.path = values.path + "/" + values.vlan;
delete values.vlan;
}
return values;
},
});
Ext.apply(me, {
items: [ipanel],
});
me.callParent();
},
});
Ext.define('PVE.sdn.VnetACLView', {
extend: 'Ext.grid.GridPanel',
alias: ['widget.pveSDNVnetACLView'],
onlineHelp: 'chapter_user_management',
stateful: true,
stateId: 'grid-acls',
// use fixed path
path: undefined,
setPath: function(path) {
let me = this;
me.path = path;
if (path === undefined) {
me.down('#groupmenu').setDisabled(true);
me.down('#usermenu').setDisabled(true);
me.down('#tokenmenu').setDisabled(true);
} else {
me.down('#groupmenu').setDisabled(false);
me.down('#usermenu').setDisabled(false);
me.down('#tokenmenu').setDisabled(false);
me.store.load();
}
},
initComponent: function() {
let me = this;
let store = Ext.create('Ext.data.Store', {
model: 'pve-acl',
proxy: {
type: 'proxmox',
url: "/api2/json/access/acl",
},
sorters: {
property: 'path',
direction: 'ASC',
},
});
store.addFilter(Ext.create('Ext.util.Filter', {
filterFn: item => item.data.path.replace(/(\/sdn\/zones\/(.*)\/(.*))\/[0-9]*$/, '$1') === me.path,
}));
let render_ugid = function(ugid, metaData, record) {
if (record.data.type === 'group') {
return '@' + ugid;
}
return Ext.String.htmlEncode(ugid);
};
let render_vlan = function(path, metaData, record) {
let vlan = 'any';
const match = path.match(/(\/sdn\/zones\/)(.*)\/(.*)\/([0-9]*)$/);
if (match) {
vlan = match[4];
}
return Ext.String.htmlEncode(vlan);
};
let columns = [
{
header: gettext('User') + '/' + gettext('Group') + '/' + gettext('API Token'),
flex: 1,
sortable: true,
renderer: render_ugid,
dataIndex: 'ugid',
},
{
header: gettext('Role'),
flex: 1,
sortable: true,
dataIndex: 'roleid',
},
{
header: gettext('VLAN'),
flex: 1,
sortable: true,
renderer: render_vlan,
dataIndex: 'path',
},
];
let sm = Ext.create('Ext.selection.RowModel', {});
let remove_btn = new Proxmox.button.Button({
text: gettext('Remove'),
disabled: true,
selModel: sm,
confirmMsg: gettext('Are you sure you want to remove this entry'),
handler: function(btn, event, rec) {
var params = {
'delete': 1,
path: rec.data.path,
roles: rec.data.roleid,
};
if (rec.data.type === 'group') {
params.groups = rec.data.ugid;
} else if (rec.data.type === 'user') {
params.users = rec.data.ugid;
} else if (rec.data.type === 'token') {
params.tokens = rec.data.ugid;
} else {
throw 'unknown data type';
}
Proxmox.Utils.API2Request({
url: '/access/acl',
params: params,
method: 'PUT',
waitMsgTarget: me,
callback: () => store.load(),
failure: response => Ext.Msg.alert(gettext('Error'), response.htmlStatus),
});
},
});
Proxmox.Utils.monStoreErrors(me, store);
Ext.apply(me, {
store: store,
selModel: sm,
tbar: [
{
text: gettext('Add'),
menu: {
xtype: 'menu',
items: [
{
text: gettext('Group Permission'),
disabled: !me.path,
itemId: 'groupmenu',
iconCls: 'fa fa-fw fa-group',
handler: function() {
var win = Ext.create('PVE.sdn.VnetACLAdd', {
aclType: 'group',
path: me.path,
});
win.on('destroy', () => store.load());
win.show();
},
},
{
text: gettext('User Permission'),
disabled: !me.path,
itemId: 'usermenu',
iconCls: 'fa fa-fw fa-user',
handler: function() {
var win = Ext.create('PVE.sdn.VnetACLAdd', {
aclType: 'user',
path: me.path,
});
win.on('destroy', () => store.load());
win.show();
},
},
{
text: gettext('API Token Permission'),
disabled: !me.path,
itemId: 'tokenmenu',
iconCls: 'fa fa-fw fa-user-o',
handler: function() {
let win = Ext.create('PVE.sdn.VnetACLAdd', {
aclType: 'token',
path: me.path,
});
win.on('destroy', () => store.load());
win.show();
},
},
],
},
},
remove_btn,
],
viewConfig: {
trackOver: false,
},
columns: columns,
listeners: {
},
});
me.callParent();
},
}, function() {
Ext.define('pve-acl-vnet', {
extend: 'Ext.data.Model',
fields: [
'path', 'type', 'ugid', 'roleid',
{
name: 'propagate',
type: 'boolean',
},
],
});
});
Ext.define('PVE.sdn.Vnet', {
extend: 'Ext.panel.Panel',
alias: 'widget.pveSDNVnet',
title: 'VNet',
onlineHelp: 'pvesdn_config_vnet',
initComponent: function() {
var me = this;
var subnetview_panel = Ext.createWidget('pveSDNSubnetView', {
title: gettext('Subnets'),
region: 'center',
border: false,
});
var vnetview_panel = Ext.createWidget('pveSDNVnetView', {
title: 'VNets',
region: 'west',
subnetview_panel: subnetview_panel,
width: '50%',
border: false,
split: true,
});
Ext.apply(me, {
layout: 'border',
items: [vnetview_panel, subnetview_panel],
listeners: {
show: function() {
subnetview_panel.fireEvent('show', subnetview_panel);
},
},
});
me.callParent();
},
});
Ext.define('PVE.sdn.SubnetInputPanel', {
extend: 'Proxmox.panel.InputPanel',
mixins: ['Proxmox.Mixin.CBind'],
onGetValues: function(values) {
let me = this;
if (me.isCreate) {
values.type = 'subnet';
values.subnet = values.cidr;
delete values.cidr;
}
return values;
},
items: [
{
xtype: 'pmxDisplayEditField',
name: 'cidr',
cbind: {
editable: '{isCreate}',
},
flex: 1,
allowBlank: false,
fieldLabel: gettext('Subnet'),
},
{
xtype: 'proxmoxtextfield',
name: 'gateway',
vtype: 'IP64Address',
fieldLabel: gettext('Gateway'),
allowBlank: true,
skipEmptyText: true,
cbind: {
deleteEmpty: "{!isCreate}",
},
},
{
xtype: 'proxmoxcheckbox',
name: 'snat',
uncheckedValue: null,
checked: false,
fieldLabel: 'SNAT',
cbind: {
deleteEmpty: "{!isCreate}",
},
},
{
xtype: 'proxmoxtextfield',
name: 'dnszoneprefix',
skipEmptyText: true,
fieldLabel: gettext('DNS Zone Prefix'),
allowBlank: true,
cbind: {
deleteEmpty: "{!isCreate}",
},
},
],
});
Ext.define('PVE.sdn.SubnetDhcpRangePanel', {
extend: 'Ext.form.FieldContainer',
mixins: ['Ext.form.field.Field'],
initComponent: function() {
let me = this;
me.callParent();
me.initField();
},
// since value is an array of objects we need to override isEquals here
isEqual: function(value1, value2) {
return JSON.stringify(value1) === JSON.stringify(value2);
},
getValue: function() {
let me = this;
let store = me.lookup('grid').getStore();
let value = [];
store.getData()
.each((item) => {
// needs a deep copy otherwise we run in to ExtJS reference
// shenaningans
value.push({
'start-address': item.data['start-address'],
'end-address': item.data['end-address'],
});
});
return value;
},
getSubmitData: function() {
let me = this;
let data = {};
let value = me.getValue()
.map((item) => `start-address=${item['start-address']},end-address=${item['end-address']}`);
if (value.length) {
data[me.getName()] = value;
} else if (!me.isCreate) {
data.delete = me.getName();
}
return data;
},
setValue: function(dhcpRanges) {
let me = this;
let store = me.lookup('grid').getStore();
let data = [];
dhcpRanges.forEach((item) => {
// needs a deep copy otherwise we run in to ExtJS reference
// shenaningans
data.push({
'start-address': item['start-address'],
'end-address': item['end-address'],
});
});
store.setData(data);
},
getErrors: function() {
let me = this;
let errors = [];
return errors;
},
controller: {
xclass: 'Ext.app.ViewController',
addRange: function() {
let me = this;
me.lookup('grid').getStore().add({});
me.getView().checkChange();
},
removeRange: function(field) {
let me = this;
let record = field.getWidgetRecord();
me.lookup('grid').getStore().remove(record);
me.getView().checkChange();
},
onValueChange: function(field, value) {
let me = this;
let record = field.getWidgetRecord();
let column = field.getWidgetColumn();
record.set(column.dataIndex, value);
record.commit();
me.getView().checkChange();
},
control: {
'grid button': {
click: 'removeRange',
},
'field': {
change: 'onValueChange',
},
},
},
items: [
{
xtype: 'grid',
reference: 'grid',
scrollable: true,
store: {
fields: ['start-address', 'end-address'],
},
columns: [
{
text: gettext('Start Address'),
xtype: 'widgetcolumn',
dataIndex: 'start-address',
flex: 1,
widget: {
xtype: 'textfield',
vtype: 'IP64Address',
},
},
{
text: gettext('End Address'),
xtype: 'widgetcolumn',
dataIndex: 'end-address',
flex: 1,
widget: {
xtype: 'textfield',
vtype: 'IP64Address',
},
},
{
xtype: 'widgetcolumn',
width: 40,
widget: {
xtype: 'button',
iconCls: 'fa fa-trash-o',
},
},
],
},
{
xtype: 'container',
layout: {
type: 'hbox',
},
items: [
{
xtype: 'button',
text: gettext('Add'),
iconCls: 'fa fa-plus-circle',
handler: 'addRange',
},
],
},
],
});
Ext.define('PVE.sdn.SubnetEdit', {
extend: 'Proxmox.window.Edit',
subject: gettext('Subnet'),
subnet: undefined,
width: 350,
base_url: undefined,
bodyPadding: 0,
initComponent: function() {
var me = this;
me.isCreate = me.subnet === undefined;
if (me.isCreate) {
me.url = me.base_url;
me.method = 'POST';
} else {
me.url = me.base_url + '/' + me.subnet;
me.method = 'PUT';
}
let ipanel = Ext.create('PVE.sdn.SubnetInputPanel', {
isCreate: me.isCreate,
title: gettext('General'),
});
let dhcpPanel = Ext.create('PVE.sdn.SubnetDhcpRangePanel', {
isCreate: me.isCreate,
title: gettext('DHCP Ranges'),
name: 'dhcp-range',
});
Ext.apply(me, {
items: [
{
xtype: 'tabpanel',
bodyPadding: 10,
items: [ipanel, dhcpPanel],
},
],
});
me.callParent();
if (!me.isCreate) {
me.load({
success: function(response, options) {
me.setValues(response.result.data);
},
});
}
},
});
Ext.define('PVE.sdn.SubnetView', {
extend: 'Ext.grid.GridPanel',
alias: 'widget.pveSDNSubnetView',
stateful: true,
stateId: 'grid-sdn-subnet',
base_url: undefined,
remove_btn: undefined,
setBaseUrl: function(url) {
let me = this;
me.base_url = url;
if (url === undefined) {
me.store.removeAll();
me.create_btn.disable();
} else {
me.remove_btn.baseurl = url + '/';
me.store.setProxy({
type: 'proxmox',
url: '/api2/json/' + url + '?pending=1',
});
me.create_btn.enable();
me.store.load();
}
},
initComponent: function() {
let me = this;
let store = new Ext.data.Store({
model: 'pve-sdn-subnet',
});
let reload = function() {
store.load();
};
let sm = Ext.create('Ext.selection.RowModel', {});
let run_editor = function() {
let rec = sm.getSelection()[0];
let win = Ext.create('PVE.sdn.SubnetEdit', {
autoShow: true,
subnet: rec.data.subnet,
base_url: me.base_url,
});
win.on('destroy', reload);
};
me.create_btn = new Proxmox.button.Button({
text: gettext('Create'),
disabled: true,
handler: function() {
let win = Ext.create('PVE.sdn.SubnetEdit', {
autoShow: true,
base_url: me.base_url,
type: 'subnet',
});
win.on('destroy', reload);
},
});
let edit_btn = new Proxmox.button.Button({
text: gettext('Edit'),
disabled: true,
selModel: sm,
handler: run_editor,
});
me.remove_btn = Ext.create('Proxmox.button.StdRemoveButton', {
selModel: sm,
baseurl: me.base_url + '/',
callback: () => store.load(),
});
let set_button_status = function() {
var rec = me.selModel.getSelection()[0];
if (!rec || rec.data.state === 'deleted') {
edit_btn.disable();
me.remove_btn.disable();
}
};
Ext.apply(me, {
store: store,
reloadStore: reload,
selModel: sm,
viewConfig: {
trackOver: false,
},
tbar: [
me.create_btn,
me.remove_btn,
edit_btn,
],
columns: [
{
header: gettext('Subnet'),
flex: 2,
dataIndex: 'cidr',
renderer: function(value, metaData, rec) {
return PVE.Utils.render_sdn_pending(rec, value, 'cidr', 1);
},
},
{
header: gettext('Gateway'),
flex: 1,
dataIndex: 'gateway',
renderer: function(value, metaData, rec) {
return PVE.Utils.render_sdn_pending(rec, value, 'gateway');
},
},
{
header: 'SNAT',
flex: 1,
dataIndex: 'snat',
renderer: function(value, metaData, rec) {
return PVE.Utils.render_sdn_pending(rec, value, 'snat');
},
},
{
header: gettext('DNS Prefix'),
flex: 1,
dataIndex: 'dnszoneprefix',
renderer: function(value, metaData, rec) {
return PVE.Utils.render_sdn_pending(rec, value, 'dnszoneprefix');
},
},
{
header: gettext('State'),
width: 100,
dataIndex: 'state',
renderer: function(value, metaData, rec) {
return PVE.Utils.render_sdn_pending_state(rec, value);
},
},
],
listeners: {
activate: reload,
itemdblclick: run_editor,
selectionchange: set_button_status,
},
});
me.callParent();
if (me.base_url) {
me.setBaseUrl(me.base_url); // load
}
},
}, function() {
Ext.define('pve-sdn-subnet', {
extend: 'Ext.data.Model',
fields: [
'cidr',
'gateway',
'snat',
],
idProperty: 'subnet',
});
});
Ext.define('PVE.sdn.ZoneContentView', {
extend: 'Ext.grid.GridPanel',
alias: 'widget.pveSDNZoneContentView',
stateful: true,
stateId: 'grid-sdnzone-content',
viewConfig: {
trackOver: false,
loadMask: false,
},
features: [
{
ftype: 'grouping',
groupHeaderTpl: '{name} ({rows.length} Item{[values.rows.length > 1 ? "s" : ""]})',
},
],
initComponent: function() {
var me = this;
if (!me.nodename) {
throw "no node name specified";
}
if (!me.zone) {
throw "no zone ID specified";
}
var baseurl = "/nodes/" + me.nodename + "/sdn/zones/" + me.zone + "/content";
if (me.zone === 'localnetwork') {
baseurl = "/nodes/" + me.nodename + "/network?type=any_local_bridge";
}
var store = Ext.create('Ext.data.Store', {
model: 'pve-sdnzone-content',
groupField: 'content',
proxy: {
type: 'proxmox',
url: '/api2/json' + baseurl,
},
sorters: {
property: 'vnet',
direction: 'ASC',
},
});
var sm = Ext.create('Ext.selection.RowModel', {});
var reload = function() {
store.load();
};
Proxmox.Utils.monStoreErrors(me, store);
Ext.apply(me, {
store: store,
selModel: sm,
tbar: [
],
columns: [
{
header: 'VNet',
width: 100,
sortable: true,
dataIndex: 'vnet',
},
{
header: 'Alias',
width: 300,
sortable: true,
dataIndex: 'alias',
},
{
header: gettext('Status'),
width: 100,
sortable: true,
dataIndex: 'status',
},
{
header: gettext('Details'),
flex: 1,
dataIndex: 'statusmsg',
},
],
listeners: {
activate: reload,
show: reload,
select: function(_sm, rec) {
let path = `/sdn/zones/${me.zone}/${rec.data.vnet}`;
me.permissions_panel.setPath(path);
},
deselect: function() {
me.permissions_panel.setPath(undefined);
},
},
});
store.load();
me.callParent();
},
}, function() {
Ext.define('pve-sdnzone-content', {
extend: 'Ext.data.Model',
fields: [
{
name: 'iface',
convert: function(value, record) {
//map local vmbr to vnet
if (record.data.iface) {
record.data.vnet = record.data.iface;
}
return value;
},
},
{
name: 'comments',
convert: function(value, record) {
//map local vmbr comments to vnet alias
if (record.data.comments) {
record.data.alias = record.data.comments;
}
return value;
},
},
'vnet',
'status',
'statusmsg',
{
name: 'text',
convert: function(value, record) {
// check for volid, because if you click on a grouping header,
// it calls convert (but with an empty volid)
if (value || record.data.vnet === null) {
return value;
}
return PVE.Utils.format_sdnvnet_type(value, {}, record);
},
},
],
idProperty: 'vnet',
});
});
Ext.define('PVE.sdn.ZoneContentPanel', {
extend: 'Ext.panel.Panel',
alias: 'widget.pveSDNZoneContentPanel',
title: 'VNet',
onlineHelp: 'pvesdn_config_vnet',
initComponent: function() {
var me = this;
var permissions_panel = Ext.createWidget('pveSDNVnetACLView', {
title: gettext('VNet Permissions'),
region: 'center',
border: false,
});
var vnetview_panel = Ext.createWidget('pveSDNZoneContentView', {
title: 'VNets',
region: 'west',
permissions_panel: permissions_panel,
nodename: me.nodename,
zone: me.zone,
width: '50%',
border: false,
split: true,
});
Ext.apply(me, {
layout: 'border',
items: [vnetview_panel, permissions_panel],
listeners: {
show: function() {
permissions_panel.fireEvent('show', permissions_panel);
},
},
});
me.callParent();
},
});
Ext.define('PVE.sdn.ZoneView', {
extend: 'Ext.grid.GridPanel',
alias: ['widget.pveSDNZoneView'],
onlineHelp: 'pvesdn_config_zone',
stateful: true,
stateId: 'grid-sdn-zone',
createSDNEditWindow: function(type, sid) {
let schema = PVE.Utils.sdnzoneSchema[type];
if (!schema || !schema.ipanel) {
throw "no editor registered for zone type: " + type;
}
Ext.create('PVE.sdn.zones.BaseEdit', {
paneltype: 'PVE.sdn.zones.' + schema.ipanel,
type: type,
zone: sid,
autoShow: true,
listeners: {
destroy: this.reloadStore,
},
});
},
initComponent: function() {
let me = this;
let store = new Ext.data.Store({
model: 'pve-sdn-zone',
proxy: {
type: 'proxmox',
url: "/api2/json/cluster/sdn/zones?pending=1",
},
sorters: {
property: 'zone',
direction: 'ASC',
},
});
let reload = function() {
store.load();
};
let sm = Ext.create('Ext.selection.RowModel', {});
let run_editor = function() {
let rec = sm.getSelection()[0];
if (!rec) {
return;
}
let type = rec.data.type,
zone = rec.data.zone;
me.createSDNEditWindow(type, zone);
};
let edit_btn = new Proxmox.button.Button({
text: gettext('Edit'),
disabled: true,
selModel: sm,
handler: run_editor,
});
let remove_btn = Ext.create('Proxmox.button.StdRemoveButton', {
selModel: sm,
baseurl: '/cluster/sdn/zones/',
callback: reload,
});
let set_button_status = function() {
var rec = me.selModel.getSelection()[0];
if (!rec || rec.data.state === 'deleted') {
edit_btn.disable();
remove_btn.disable();
}
};
// else we cannot dynamically generate the add menu handlers
let addHandleGenerator = function(type) {
return function() { me.createSDNEditWindow(type); };
};
let addMenuItems = [];
for (const [type, zone] of Object.entries(PVE.Utils.sdnzoneSchema)) {
if (zone.hideAdd) {
continue;
}
addMenuItems.push({
text: PVE.Utils.format_sdnzone_type(type),
iconCls: 'fa fa-fw fa-' + zone.faIcon,
handler: addHandleGenerator(type),
});
}
Ext.apply(me, {
store: store,
reloadStore: reload,
selModel: sm,
viewConfig: {
trackOver: false,
},
tbar: [
{
text: gettext('Add'),
menu: new Ext.menu.Menu({
items: addMenuItems,
}),
},
remove_btn,
edit_btn,
],
columns: [
{
header: 'ID',
width: 100,
dataIndex: 'zone',
renderer: function(value, metaData, rec) {
return PVE.Utils.render_sdn_pending(rec, value, 'zone', 1);
},
},
{
header: gettext('Type'),
width: 100,
dataIndex: 'type',
renderer: function(value, metaData, rec) {
return PVE.Utils.render_sdn_pending(rec, value, 'type', 1);
},
},
{
header: 'MTU',
width: 50,
dataIndex: 'mtu',
renderer: function(value, metaData, rec) {
return PVE.Utils.render_sdn_pending(rec, value, 'mtu');
},
},
{
header: 'IPAM',
flex: 3,
dataIndex: 'ipam',
renderer: function(value, metaData, rec) {
return PVE.Utils.render_sdn_pending(rec, value, 'ipam');
},
},
{
header: gettext('Domain'),
flex: 3,
dataIndex: 'dnszone',
renderer: function(value, metaData, rec) {
return PVE.Utils.render_sdn_pending(rec, value, 'dnszone');
},
},
{
header: gettext('DNS'),
flex: 3,
dataIndex: 'dns',
renderer: function(value, metaData, rec) {
return PVE.Utils.render_sdn_pending(rec, value, 'dns');
},
},
{
header: gettext('Reverse DNS'),
flex: 3,
dataIndex: 'reversedns',
renderer: function(value, metaData, rec) {
return PVE.Utils.render_sdn_pending(rec, value, 'reversedns');
},
},
{
header: gettext('Nodes'),
flex: 3,
dataIndex: 'nodes',
renderer: function(value, metaData, rec) {
return PVE.Utils.render_sdn_pending(rec, value, 'nodes');
},
},
{
header: gettext('State'),
width: 100,
dataIndex: 'state',
renderer: function(value, metaData, rec) {
return PVE.Utils.render_sdn_pending_state(rec, value);
},
},
],
listeners: {
activate: reload,
itemdblclick: run_editor,
selectionchange: set_button_status,
},
});
me.callParent();
},
});
Ext.define('PVE.sdn.IpamEditInputPanel', {
extend: 'Proxmox.panel.InputPanel',
mixins: ['Proxmox.Mixin.CBind'],
isCreate: false,
onGetValues: function(values) {
let me = this;
if (!values.vmid) {
delete values.vmid;
}
return values;
},
items: [
{
xtype: 'pmxDisplayEditField',
name: 'vmid',
fieldLabel: 'VMID',
allowBlank: false,
editable: false,
cbind: {
hidden: '{isCreate}',
},
},
{
xtype: 'pmxDisplayEditField',
name: 'mac',
fieldLabel: 'MAC',
allowBlank: false,
cbind: {
editable: '{isCreate}',
},
},
{
xtype: 'proxmoxtextfield',
name: 'ip',
fieldLabel: gettext('IP Address'),
allowBlank: false,
},
],
});
Ext.define('PVE.sdn.IpamEdit', {
extend: 'Proxmox.window.Edit',
subject: gettext('DHCP Mapping'),
width: 350,
isCreate: false,
mapping: {},
url: '/cluster/sdn/vnets',
submitUrl: function(url, values) {
return `${url}/${values.vnet}/ips`;
},
initComponent: function() {
var me = this;
me.method = me.isCreate ? 'POST' : 'PUT';
let ipanel = Ext.create('PVE.sdn.IpamEditInputPanel', {
isCreate: me.isCreate,
});
Ext.apply(me, {
items: [
ipanel,
],
});
me.callParent();
ipanel.setValues(me.mapping);
},
});
Ext.define('PVE.sdn.Options', {
extend: 'Ext.panel.Panel',
alias: 'widget.pveSDNOptions',
title: 'Options',
layout: {
type: 'vbox',
align: 'stretch',
},
onlineHelp: 'pvesdn_config_controllers',
items: [
{
xtype: 'pveSDNControllerView',
title: gettext('Controllers'),
flex: 1,
padding: '0 0 20 0',
border: 0,
},
{
xtype: 'pveSDNIpamView',
title: 'IPAM',
flex: 1,
padding: '0 0 20 0',
border: 0,
}, {
xtype: 'pveSDNDnsView',
title: 'DNS',
flex: 1,
border: 0,
},
],
});
Ext.define('PVE.panel.SDNControllerBase', {
extend: 'Proxmox.panel.InputPanel',
type: '',
onGetValues: function(values) {
var me = this;
if (me.isCreate) {
values.type = me.type;
} else {
delete values.controller;
}
return values;
},
});
Ext.define('PVE.sdn.controllers.BaseEdit', {
extend: 'Proxmox.window.Edit',
initComponent: function() {
var me = this;
me.isCreate = !me.controllerid;
if (me.isCreate) {
me.url = '/api2/extjs/cluster/sdn/controllers';
me.method = 'POST';
} else {
me.url = '/api2/extjs/cluster/sdn/controllers/' + me.controllerid;
me.method = 'PUT';
}
var ipanel = Ext.create(me.paneltype, {
type: me.type,
isCreate: me.isCreate,
controllerid: me.controllerid,
});
Ext.apply(me, {
subject: PVE.Utils.format_sdncontroller_type(me.type),
isAdd: true,
items: [ipanel],
});
me.callParent();
if (!me.isCreate) {
me.load({
success: function(response, options) {
var values = response.result.data;
var ctypes = values.content || '';
values.content = ctypes.split(',');
if (values.nodes) {
values.nodes = values.nodes.split(',');
}
values.enable = values.disable ? 0 : 1;
ipanel.setValues(values);
},
});
}
},
});
Ext.define('PVE.sdn.controllers.EvpnInputPanel', {
extend: 'PVE.panel.SDNControllerBase',
onlineHelp: 'pvesdn_controller_plugin_evpn',
initComponent: function() {
var me = this;
me.items = [
{
xtype: me.isCreate ? 'textfield' : 'displayfield',
name: 'controller',
maxLength: 8,
value: me.controllerid || '',
fieldLabel: 'ID',
allowBlank: false,
},
{
xtype: 'proxmoxintegerfield',
name: 'asn',
minValue: 1,
maxValue: 4294967295,
value: 65000,
fieldLabel: 'ASN #',
allowBlank: false,
},
{
xtype: 'textfield',
name: 'peers',
fieldLabel: gettext('Peers'),
allowBlank: false,
},
];
me.callParent();
},
});
Ext.define('PVE.sdn.controllers.BgpInputPanel', {
extend: 'PVE.panel.SDNControllerBase',
onlineHelp: 'pvesdn_controller_plugin_evpn',
onGetValues: function(values) {
var me = this;
if (me.isCreate) {
values.type = me.type;
values.controller = 'bgp' + values.node;
} else {
delete values.controller;
}
return values;
},
initComponent: function() {
var me = this;
me.items = [
{
xtype: 'pveNodeSelector',
name: 'node',
fieldLabel: gettext('Node'),
multiSelect: false,
autoSelect: false,
allowBlank: false,
},
{
xtype: 'proxmoxintegerfield',
name: 'asn',
minValue: 1,
maxValue: 4294967295,
value: 65000,
fieldLabel: 'ASN #',
allowBlank: false,
},
{
xtype: 'textfield',
name: 'peers',
fieldLabel: gettext('Peers'),
allowBlank: false,
},
{
xtype: 'proxmoxcheckbox',
name: 'ebgp',
uncheckedValue: 0,
checked: false,
fieldLabel: 'EBGP',
},
];
me.advancedItems = [
{
xtype: 'textfield',
name: 'loopback',
fieldLabel: gettext('Loopback Interface'),
},
{
xtype: 'proxmoxintegerfield',
name: 'ebgp-multihop',
minValue: 1,
maxValue: 100,
fieldLabel: 'ebgp-multihop',
allowBlank: true,
},
{
xtype: 'proxmoxcheckbox',
name: 'bgp-multipath-as-path-relax',
uncheckedValue: 0,
checked: false,
fieldLabel: 'bgp-multipath-as-path-relax',
},
];
me.callParent();
},
});
Ext.define('PVE.sdn.controllers.IsisInputPanel', {
extend: 'PVE.panel.SDNControllerBase',
onlineHelp: 'pvesdn_controller_plugin_evpn',
onGetValues: function(values) {
var me = this;
if (me.isCreate) {
values.type = me.type;
values.controller = 'isis' + values.node;
} else {
delete values.controller;
}
return values;
},
initComponent: function() {
var me = this;
me.items = [
{
xtype: 'pveNodeSelector',
name: 'node',
fieldLabel: gettext('Node'),
multiSelect: false,
autoSelect: false,
allowBlank: false,
},
{
xtype: 'textfield',
name: 'isis-domain',
fieldLabel: 'Domain',
allowBlank: false,
},
{
xtype: 'textfield',
name: 'isis-net',
fieldLabel: 'Network entity title',
allowBlank: false,
},
{
xtype: 'textfield',
name: 'isis-ifaces',
fieldLabel: gettext('Interfaces'),
allowBlank: false,
},
];
me.advancedItems = [
{
xtype: 'textfield',
name: 'loopback',
fieldLabel: gettext('Loopback Interface'),
},
];
me.callParent();
},
});
Ext.define('PVE.sdn.IpamView', {
extend: 'Ext.grid.GridPanel',
alias: ['widget.pveSDNIpamView'],
stateful: true,
stateId: 'grid-sdn-ipam',
createSDNEditWindow: function(type, sid) {
let schema = PVE.Utils.sdnipamSchema[type];
if (!schema || !schema.ipanel) {
throw "no editor registered for ipam type: " + type;
}
Ext.create('PVE.sdn.ipams.BaseEdit', {
paneltype: 'PVE.sdn.ipams.' + schema.ipanel,
type: type,
ipam: sid,
autoShow: true,
listeners: {
destroy: this.reloadStore,
},
});
},
initComponent: function() {
let me = this;
let store = new Ext.data.Store({
model: 'pve-sdn-ipam',
proxy: {
type: 'proxmox',
url: "/api2/json/cluster/sdn/ipams",
},
sorters: {
property: 'ipam',
direction: 'ASC',
},
});
let sm = Ext.create('Ext.selection.RowModel', {});
let run_editor = function() {
let rec = sm.getSelection()[0];
if (!rec) {
return;
}
let type = rec.data.type, ipam = rec.data.ipam;
me.createSDNEditWindow(type, ipam);
};
let edit_btn = new Proxmox.button.Button({
text: gettext('Edit'),
disabled: true,
selModel: sm,
handler: run_editor,
});
let remove_btn = Ext.create('Proxmox.button.StdRemoveButton', {
selModel: sm,
baseurl: '/cluster/sdn/ipams/',
callback: () => store.load(),
});
// else we cannot dynamically generate the add menu handlers
let addHandleGenerator = function(type) {
return function() { me.createSDNEditWindow(type); };
};
let addMenuItems = [];
for (const [type, ipam] of Object.entries(PVE.Utils.sdnipamSchema)) {
if (ipam.hideAdd) {
continue;
}
addMenuItems.push({
text: PVE.Utils.format_sdnipam_type(type),
iconCls: 'fa fa-fw fa-' + ipam.faIcon,
handler: addHandleGenerator(type),
});
}
Ext.apply(me, {
store: store,
reloadStore: () => store.load(),
selModel: sm,
viewConfig: {
trackOver: false,
},
tbar: [
{
text: gettext('Add'),
menu: new Ext.menu.Menu({
items: addMenuItems,
}),
},
remove_btn,
edit_btn,
],
columns: [
{
header: 'ID',
flex: 2,
dataIndex: 'ipam',
},
{
header: gettext('Type'),
flex: 1,
dataIndex: 'type',
renderer: PVE.Utils.format_sdnipam_type,
},
{
header: 'url',
flex: 1,
dataIndex: 'url',
},
],
listeners: {
activate: () => store.load(),
itemdblclick: run_editor,
},
});
store.load();
me.callParent();
},
});
Ext.define('PVE.panel.SDNIpamBase', {
extend: 'Proxmox.panel.InputPanel',
type: '',
onGetValues: function(values) {
var me = this;
if (me.isCreate) {
values.type = me.type;
} else {
delete values.ipam;
}
return values;
},
initComponent: function() {
var me = this;
me.callParent();
},
});
Ext.define('PVE.sdn.ipams.BaseEdit', {
extend: 'Proxmox.window.Edit',
initComponent: function() {
var me = this;
me.isCreate = !me.ipam;
if (me.isCreate) {
me.url = '/api2/extjs/cluster/sdn/ipams';
me.method = 'POST';
} else {
me.url = '/api2/extjs/cluster/sdn/ipams/' + me.ipam;
me.method = 'PUT';
}
var ipanel = Ext.create(me.paneltype, {
type: me.type,
isCreate: me.isCreate,
ipam: me.ipam,
});
Ext.apply(me, {
subject: PVE.Utils.format_sdnipam_type(me.type),
isAdd: true,
items: [ipanel],
});
me.callParent();
if (!me.isCreate) {
me.load({
success: function(response, options) {
var values = response.result.data;
var ctypes = values.content || '';
values.content = ctypes.split(',');
if (values.nodes) {
values.nodes = values.nodes.split(',');
}
values.enable = values.disable ? 0 : 1;
ipanel.setValues(values);
},
});
}
},
});
Ext.define('PVE.sdn.ipams.NetboxInputPanel', {
extend: 'PVE.panel.SDNIpamBase',
onlineHelp: 'pvesdn_ipam_plugin_netbox',
onGetValues: function(values) {
var me = this;
if (me.isCreate) {
values.type = me.type;
} else {
delete values.ipam;
}
return values;
},
initComponent: function() {
var me = this;
me.items = [
{
xtype: me.isCreate ? 'textfield' : 'displayfield',
name: 'ipam',
maxLength: 10,
value: me.zone || '',
fieldLabel: 'ID',
allowBlank: false,
},
{
xtype: 'textfield',
name: 'url',
fieldLabel: gettext('URL'),
allowBlank: false,
},
{
xtype: 'textfield',
name: 'token',
fieldLabel: gettext('Token'),
allowBlank: false,
},
];
me.callParent();
},
});
Ext.define('PVE.sdn.ipams.PVEIpamInputPanel', {
extend: 'PVE.panel.SDNIpamBase',
onlineHelp: 'pvesdn_ipam_plugin_pveipam',
onGetValues: function(values) {
var me = this;
if (me.isCreate) {
values.type = me.type;
} else {
delete values.ipam;
}
return values;
},
initComponent: function() {
var me = this;
me.items = [
{
xtype: me.isCreate ? 'textfield' : 'displayfield',
name: 'ipam',
maxLength: 10,
value: me.zone || '',
fieldLabel: 'ID',
allowBlank: false,
},
];
me.callParent();
},
});
Ext.define('PVE.sdn.ipams.PhpIpamInputPanel', {
extend: 'PVE.panel.SDNIpamBase',
onlineHelp: 'pvesdn_ipam_plugin_phpipam',
onGetValues: function(values) {
var me = this;
if (me.isCreate) {
values.type = me.type;
} else {
delete values.ipam;
}
return values;
},
initComponent: function() {
var me = this;
me.items = [
{
xtype: me.isCreate ? 'textfield' : 'displayfield',
name: 'ipam',
maxLength: 10,
value: me.zone || '',
fieldLabel: 'ID',
allowBlank: false,
},
{
xtype: 'textfield',
name: 'url',
fieldLabel: gettext('URL'),
allowBlank: false,
},
{
xtype: 'textfield',
name: 'token',
fieldLabel: gettext('Token'),
allowBlank: false,
},
{
xtype: 'textfield',
name: 'section',
fieldLabel: gettext('Section'),
allowBlank: false,
},
];
me.callParent();
},
});
Ext.define('PVE.sdn.DnsView', {
extend: 'Ext.grid.GridPanel',
alias: ['widget.pveSDNDnsView'],
stateful: true,
stateId: 'grid-sdn-dns',
createSDNEditWindow: function(type, sid) {
let schema = PVE.Utils.sdndnsSchema[type];
if (!schema || !schema.ipanel) {
throw "no editor registered for dns type: " + type;
}
Ext.create('PVE.sdn.dns.BaseEdit', {
paneltype: 'PVE.sdn.dns.' + schema.ipanel,
type: type,
dns: sid,
autoShow: true,
listeners: {
destroy: this.reloadStore,
},
});
},
initComponent: function() {
let me = this;
let store = new Ext.data.Store({
model: 'pve-sdn-dns',
proxy: {
type: 'proxmox',
url: "/api2/json/cluster/sdn/dns",
},
sorters: {
property: 'dns',
direction: 'ASC',
},
});
let sm = Ext.create('Ext.selection.RowModel', {});
let run_editor = function() {
let rec = sm.getSelection()[0];
if (!rec) {
return;
}
let type = rec.data.type,
dns = rec.data.dns;
me.createSDNEditWindow(type, dns);
};
let edit_btn = new Proxmox.button.Button({
text: gettext('Edit'),
disabled: true,
selModel: sm,
handler: run_editor,
});
let remove_btn = Ext.create('Proxmox.button.StdRemoveButton', {
selModel: sm,
baseurl: '/cluster/sdn/dns/',
callback: () => store.load(),
});
// else we cannot dynamically generate the add menu handlers
let addHandleGenerator = function(type) {
return function() { me.createSDNEditWindow(type); };
};
let addMenuItems = [];
for (const [type, dns] of Object.entries(PVE.Utils.sdndnsSchema)) {
if (dns.hideAdd) {
continue;
}
addMenuItems.push({
text: PVE.Utils.format_sdndns_type(type),
iconCls: 'fa fa-fw fa-' + dns.faIcon,
handler: addHandleGenerator(type),
});
}
Ext.apply(me, {
store: store,
reloadStore: () => store.load(),
selModel: sm,
viewConfig: {
trackOver: false,
},
tbar: [
{
text: gettext('Add'),
menu: new Ext.menu.Menu({
items: addMenuItems,
}),
},
remove_btn,
edit_btn,
],
columns: [
{
header: 'ID',
flex: 2,
dataIndex: 'dns',
},
{
header: gettext('Type'),
flex: 1,
dataIndex: 'type',
renderer: PVE.Utils.format_sdndns_type,
},
{
header: 'url',
flex: 1,
dataIndex: 'url',
},
],
listeners: {
activate: () => store.load(),
itemdblclick: run_editor,
},
});
store.load();
me.callParent();
},
});
Ext.define('PVE.panel.SDNDnsBase', {
extend: 'Proxmox.panel.InputPanel',
type: '',
onGetValues: function(values) {
var me = this;
if (me.isCreate) {
values.type = me.type;
} else {
delete values.dns;
}
return values;
},
initComponent: function() {
var me = this;
me.callParent();
},
});
Ext.define('PVE.sdn.dns.BaseEdit', {
extend: 'Proxmox.window.Edit',
initComponent: function() {
var me = this;
me.isCreate = !me.dns;
if (me.isCreate) {
me.url = '/api2/extjs/cluster/sdn/dns';
me.method = 'POST';
} else {
me.url = '/api2/extjs/cluster/sdn/dns/' + me.dns;
me.method = 'PUT';
}
var ipanel = Ext.create(me.paneltype, {
type: me.type,
isCreate: me.isCreate,
dns: me.dns,
});
Ext.apply(me, {
subject: PVE.Utils.format_sdndns_type(me.type),
isAdd: true,
items: [ipanel],
});
me.callParent();
if (!me.isCreate) {
me.load({
success: function(response, options) {
var values = response.result.data;
var ctypes = values.content || '';
values.content = ctypes.split(',');
if (values.nodes) {
values.nodes = values.nodes.split(',');
}
values.enable = values.disable ? 0 : 1;
ipanel.setValues(values);
},
});
}
},
});
Ext.define('PVE.sdn.dns.PowerdnsInputPanel', {
extend: 'PVE.panel.SDNDnsBase',
onlineHelp: 'pvesdn_dns_plugin_powerdns',
onGetValues: function(values) {
var me = this;
if (me.isCreate) {
values.type = me.type;
} else {
delete values.dns;
}
return values;
},
initComponent: function() {
var me = this;
me.items = [
{
xtype: me.isCreate ? 'textfield' : 'displayfield',
name: 'dns',
maxLength: 10,
value: me.dns || '',
fieldLabel: 'ID',
allowBlank: false,
},
{
xtype: 'textfield',
name: 'url',
fieldLabel: 'URL',
allowBlank: false,
},
{
xtype: 'textfield',
name: 'key',
fieldLabel: gettext('API Key'),
allowBlank: false,
},
{
xtype: 'proxmoxintegerfield',
name: 'ttl',
fieldLabel: 'TTL',
allowBlank: true,
},
];
me.callParent();
},
});
Ext.define('PVE.panel.SDNZoneBase', {
extend: 'Proxmox.panel.InputPanel',
type: '',
onGetValues: function(values) {
var me = this;
if (me.isCreate) {
values.type = me.type;
} else {
delete values.zone;
}
return values;
},
initComponent: function() {
var me = this;
me.items.unshift({
xtype: me.isCreate ? 'textfield' : 'displayfield',
name: 'zone',
maxLength: 8,
value: me.zone || '',
fieldLabel: 'ID',
allowBlank: false,
});
me.items.push(
{
xtype: 'proxmoxintegerfield',
name: 'mtu',
minValue: 100,
maxValue: 65000,
fieldLabel: 'MTU',
allowBlank: true,
emptyText: 'auto',
deleteEmpty: !me.isCreate,
},
{
xtype: 'pveNodeSelector',
name: 'nodes',
fieldLabel: gettext('Nodes'),
emptyText: gettext('All') + ' (' + gettext('No restrictions') +')',
multiSelect: true,
autoSelect: false,
},
{
xtype: 'pveSDNIpamSelector',
fieldLabel: gettext('IPAM'),
name: 'ipam',
value: me.ipam || 'pve',
allowBlank: false,
},
);
me.advancedItems = me.advancedItems ?? [];
me.advancedItems.unshift(
{
xtype: 'pveSDNDnsSelector',
fieldLabel: gettext('DNS Server'),
name: 'dns',
value: '',
allowBlank: true,
},
{
xtype: 'pveSDNDnsSelector',
fieldLabel: gettext('Reverse DNS Server'),
name: 'reversedns',
value: '',
allowBlank: true,
},
{
xtype: 'proxmoxtextfield',
name: 'dnszone',
skipEmptyText: true,
fieldLabel: gettext('DNS Zone'),
allowBlank: true,
deleteEmpty: !me.isCreate,
},
);
me.callParent();
},
});
Ext.define('PVE.sdn.zones.BaseEdit', {
extend: 'Proxmox.window.Edit',
width: 400,
initComponent: function() {
var me = this;
me.isCreate = !me.zone;
if (me.isCreate) {
me.url = '/api2/extjs/cluster/sdn/zones';
me.method = 'POST';
} else {
me.url = '/api2/extjs/cluster/sdn/zones/' + me.zone;
me.method = 'PUT';
}
var ipanel = Ext.create(me.paneltype, {
type: me.type,
isCreate: me.isCreate,
zone: me.zone,
});
Ext.apply(me, {
subject: PVE.Utils.format_sdnzone_type(me.type),
isAdd: true,
items: [ipanel],
});
me.callParent();
if (!me.isCreate) {
me.load({
success: function(response, options) {
var values = response.result.data;
var ctypes = values.content || '';
values.content = ctypes.split(',');
if (values.nodes) {
values.nodes = values.nodes.split(',');
}
if (values.exitnodes) {
values.exitnodes = values.exitnodes.split(',');
}
values.enable = values.disable ? 0 : 1;
ipanel.setValues(values);
},
});
}
},
});
Ext.define('PVE.sdn.zones.EvpnInputPanel', {
extend: 'PVE.panel.SDNZoneBase',
onlineHelp: 'pvesdn_zone_plugin_evpn',
onGetValues: function(values) {
var me = this;
if (me.isCreate) {
values.type = me.type;
}
return values;
},
initComponent: function() {
var me = this;
me.items = [
{
xtype: 'pveSDNControllerSelector',
fieldLabel: gettext('Controller'),
name: 'controller',
value: '',
allowBlank: false,
},
{
xtype: 'proxmoxintegerfield',
name: 'vrf-vxlan',
minValue: 1,
maxValue: 16000000,
fieldLabel: 'VRF-VXLAN Tag',
allowBlank: false,
},
{
xtype: 'proxmoxtextfield',
name: 'mac',
fieldLabel: gettext('VNet MAC Address'),
vtype: 'MacAddress',
allowBlank: true,
emptyText: 'auto',
deleteEmpty: !me.isCreate,
},
{
xtype: 'pveNodeSelector',
name: 'exitnodes',
fieldLabel: gettext('Exit Nodes'),
multiSelect: true,
autoSelect: false,
},
{
xtype: 'pveNodeSelector',
name: 'exitnodes-primary',
fieldLabel: gettext('Primary Exit Node'),
multiSelect: false,
autoSelect: false,
},
{
xtype: 'proxmoxcheckbox',
name: 'exitnodes-local-routing',
uncheckedValue: null,
checked: false,
fieldLabel: gettext('Exit Nodes Local Routing'),
deleteEmpty: !me.isCreate,
},
{
xtype: 'proxmoxcheckbox',
name: 'advertise-subnets',
uncheckedValue: null,
checked: false,
fieldLabel: gettext('Advertise Subnets'),
deleteEmpty: !me.isCreate,
},
{
xtype: 'proxmoxcheckbox',
name: 'disable-arp-nd-suppression',
uncheckedValue: null,
checked: false,
fieldLabel: gettext('Disable ARP-nd Suppression'),
deleteEmpty: !me.isCreate,
},
{
xtype: 'proxmoxtextfield',
name: 'rt-import',
fieldLabel: gettext('Route Target Import'),
allowBlank: true,
deleteEmpty: !me.isCreate,
},
];
me.callParent();
},
});
Ext.define('PVE.sdn.zones.QinQInputPanel', {
extend: 'PVE.panel.SDNZoneBase',
onlineHelp: 'pvesdn_zone_plugin_qinq',
onGetValues: function(values) {
let me = this;
if (me.isCreate) {
values.type = me.type;
} else {
delete values.sdn;
}
return values;
},
initComponent: function() {
let me = this;
me.items = [
{
xtype: 'textfield',
name: 'bridge',
fieldLabel: 'Bridge',
allowBlank: false,
},
{
xtype: 'proxmoxintegerfield',
name: 'tag',
minValue: 0,
maxValue: 4096,
fieldLabel: gettext('Service VLAN'),
allowBlank: false,
},
{
xtype: 'proxmoxKVComboBox',
name: 'vlan-protocol',
fieldLabel: gettext('Service VLAN Protocol'),
allowBlank: true,
value: '802.1q',
comboItems: [
['802.1q', '802.1q'],
['802.1ad', '802.1ad'],
],
},
];
me.callParent();
},
});
Ext.define('PVE.sdn.zones.SimpleInputPanel', {
extend: 'PVE.panel.SDNZoneBase',
onlineHelp: 'pvesdn_zone_plugin_simple',
onGetValues: function(values) {
var me = this;
if (me.isCreate) {
values.type = me.type;
} else {
delete values.zone;
}
return values;
},
initComponent: function() {
var me = this;
me.items = [];
me.advancedItems = [
{
xtype: 'proxmoxcheckbox',
name: 'dhcp',
inputValue: 'dnsmasq',
uncheckedValue: null,
checked: false,
fieldLabel: gettext('automatic DHCP'),
deleteEmpty: !me.isCreate,
},
];
me.callParent();
},
});
Ext.define('PVE.sdn.zones.VlanInputPanel', {
extend: 'PVE.panel.SDNZoneBase',
onlineHelp: 'pvesdn_zone_plugin_vlan',
onGetValues: function(values) {
var me = this;
if (me.isCreate) {
values.type = me.type;
} else {
delete values.zone;
}
return values;
},
initComponent: function() {
var me = this;
me.items = [
{
xtype: 'textfield',
name: 'bridge',
fieldLabel: 'Bridge',
allowBlank: false,
},
];
me.callParent();
},
});
Ext.define('PVE.sdn.zones.VxlanInputPanel', {
extend: 'PVE.panel.SDNZoneBase',
onlineHelp: 'pvesdn_zone_plugin_vxlan',
onGetValues: function(values) {
var me = this;
if (me.isCreate) {
values.type = me.type;
} else {
delete values.zone;
}
delete values.mode;
return values;
},
initComponent: function() {
var me = this;
me.items = [
{
xtype: 'textfield',
name: 'peers',
fieldLabel: gettext('Peer Address List'),
allowBlank: false,
},
];
me.callParent();
},
});
Ext.define('PVE.storage.ContentView', {
extend: 'Ext.grid.GridPanel',
alias: 'widget.pveStorageContentView',
viewConfig: {
trackOver: false,
loadMask: false,
},
initComponent: function() {
var me = this;
if (!me.nodename) {
me.nodename = me.pveSelNode.data.node;
if (!me.nodename) {
throw "no node name specified";
}
}
const nodename = me.nodename;
if (!me.storage) {
me.storage = me.pveSelNode.data.storage;
if (!me.storage) {
throw "no storage ID specified";
}
}
const storage = me.storage;
var content = me.content;
if (!content) {
throw "no content type specified";
}
const baseurl = `/nodes/${nodename}/storage/${storage}/content`;
let store = me.store = Ext.create('Ext.data.Store', {
model: 'pve-storage-content',
proxy: {
type: 'proxmox',
url: '/api2/json' + baseurl,
extraParams: {
content: content,
},
},
sorters: {
property: 'volid',
direction: 'ASC',
},
});
if (!me.sm) {
me.sm = Ext.create('Ext.selection.RowModel', {});
}
let sm = me.sm;
let reload = () => store.load();
Proxmox.Utils.monStoreErrors(me, store);
if (!me.tbar) {
me.tbar = [];
}
if (me.useUploadButton) {
me.tbar.unshift(
{
xtype: 'button',
text: gettext('Upload'),
disabled: !me.enableUploadButton,
handler: function() {
Ext.create('PVE.window.UploadToStorage', {
nodename: nodename,
storage: storage,
content: content,
autoShow: true,
taskDone: () => reload(),
});
},
},
{
xtype: 'button',
text: gettext('Download from URL'),
disabled: !me.enableDownloadUrlButton,
handler: function() {
Ext.create('PVE.window.DownloadUrlToStorage', {
nodename: nodename,
storage: storage,
content: content,
autoShow: true,
taskDone: () => reload(),
});
},
},
'-',
);
}
if (!me.useCustomRemoveButton) {
me.tbar.push({
xtype: 'proxmoxStdRemoveButton',
selModel: sm,
enableFn: rec => !rec?.data?.protected,
delay: 5,
callback: () => reload(),
baseurl: baseurl + '/',
});
}
me.tbar.push(
'->',
gettext('Search') + ':',
' ',
{
xtype: 'textfield',
width: 200,
enableKeyEvents: true,
emptyText: content === 'backup' ? gettext('Name, Format, Notes') : gettext('Name, Format'),
listeners: {
keyup: {
buffer: 500,
fn: function(field) {
let needle = field.getValue().toLocaleLowerCase();
store.clearFilter(true);
store.filter([
{
filterFn: ({ data }) =>
data.text?.toLocaleLowerCase().includes(needle) ||
data.notes?.toLocaleLowerCase().includes(needle),
},
]);
},
},
change: function(field, newValue, oldValue) {
if (newValue !== this.originalValue) {
this.triggers.clear.setVisible(true);
}
},
},
triggers: {
clear: {
cls: 'pmx-clear-trigger',
weight: -1,
hidden: true,
handler: function() {
this.triggers.clear.setVisible(false);
this.setValue(this.originalValue);
store.clearFilter();
},
},
},
},
);
let availableColumns = {
'name': {
header: gettext('Name'),
flex: 2,
sortable: true,
renderer: PVE.Utils.render_storage_content,
dataIndex: 'text',
},
'notes': {
header: gettext('Notes'),
flex: 1,
renderer: Ext.htmlEncode,
dataIndex: 'notes',
},
'protected': {
header: `Encryption Key - Storage '${me.sid}' (${shortKeyFP})
-----BEGIN PROXMOX BACKUP KEY-----
${prettifiedKey}
-----END PROXMOX BACKUP KEY-----
${gettext('Warning')} : ` +
`${tagEl} `);
},
},
});
},
});