apache · DaanHoogland · Aug 13, 2026 · Aug 14, 2026 · Aug 14, 2026 · Aug 14, 2026
diff --git a/api/src/main/java/com/cloud/deploy/DeploymentClusterPlanner.java b/api/src/main/java/com/cloud/deploy/DeploymentClusterPlanner.java
@@ -68,6 +68,18 @@ public interface DeploymentClusterPlanner extends DeploymentPlanner {
             ConfigKey.Kind.Select,
             "random,firstfit,userdispersing,firstfitleastconsumed");
 
+    ConfigKey<Boolean> ApplyAllocationAlgorithmToPods = new ConfigKey<>("Advanced", Boolean.class, "apply.allocation.algorithm.to.pods", "false",
+            "If true, deployment planner applies the allocation heuristics at pods first in the given datacenter during VM resource allocation", true);
+
+    ConfigKey<String> HostCapacityTypeToOrderClusters = new ConfigKey<>("Advanced", String.class, "host.capacityType.to.order.clusters", "CPU",
+            "The host capacity type (CPU, RAM, COMBINED) is used by deployment planner to order clusters during VM resource allocation", true);
+
+    ConfigKey<Float> VmUserDispersionWeight = new ConfigKey<>("Advanced", Float.class, "vm.user.dispersion.weight", "1",
+            "Weight for user dispersion heuristic (as a value between 0 and 1) applied to resource allocation during vm deployment. Weight for capacity heuristic will be (1 - weight of user dispersion)", true);
+
+    ConfigKey<String> ImplicitHostTags = new ConfigKey<>("Advanced", String.class, "implicit.host.tags", "GPU",
+            "Tag hosts at the time of host discovery based on the host properties/capabilities", true);
+
     /**
      * This is called to determine list of possible clusters where a virtual
      * machine can be deployed.

diff --git a/api/src/main/java/com/cloud/network/NetworkModel.java b/api/src/main/java/com/cloud/network/NetworkModel.java
@@ -91,12 +91,31 @@
    List<String> metadataFileNames = new ArrayList<>(Arrays.asList(SERVICE_OFFERING_FILE, AVAILABILITY_ZONE_FILE, LOCAL_HOSTNAME_FILE, LOCAL_IPV4_FILE, PUBLIC_HOSTNAME_FILE, PUBLIC_IPV4_FILE,
            INSTANCE_ID_FILE, VM_ID_FILE, PUBLIC_KEYS_FILE, CLOUD_IDENTIFIER_FILE, CLOUD_NAME_FILE, HYPERVISOR_HOST_NAME_FILE));

    static final ConfigKey<Integer> MACIdentifier = new ConfigKey<>("Advanced",Integer.class, "mac.identifier", "0",
            "This value will be used while generating the mac addresses for isolated and shared networks. The hexadecimal equivalent value will be present at the 2nd octet of the mac address. Default value is zero (0) which means that the DB id of the zone will be used.", true, ConfigKey.Scope.Zone);

     static final ConfigKey<Boolean> AdminIsAllowedToDeployAnywhere = new ConfigKey<>("Advanced",Boolean.class, "admin.is.allowed.to.deploy.anywhere", "false",
             "This will determine if the root admin is allowed to deploy in networks in subdomains.", true, ConfigKey.Scope.Global);
 
+    ConfigKey<Boolean> SecurityGroupDefaultAdding = new ConfigKey<>("Network", Boolean.class, "network.securitygroups.defaultadding", "true",
+            "If true, the user VM would be added to the default security group by default", true);
+
+    ConfigKey<String> CloudIdentifier = new ConfigKey<>("Hidden", String.class, "cloud.identifier", null,
+            "A unique identifier for the cloud.", true);
+
+    ConfigKey<Boolean> SubDomainNetworkAccess = new ConfigKey<>("Advanced", Boolean.class, "allow.subdomain.network.access", "true",
+            "Allow subdomains to use networks dedicated to their parent domain(s)", true);
+
+    ConfigKey<Boolean> ExecuteInSequenceNetworkElementCommands = new ConfigKey<>("Advanced", Boolean.class, "execute.in.sequence.network.element.commands", "false",
+            "If set to true, DhcpEntryCommand, SavePasswordCommand, VmDataCommand will be synchronized on the agent side."
+                    + " If set to false, these commands become asynchronous. Default value is false.", true);
+
+    ConfigKey<Integer> ExternalNetworkStatsInterval = new ConfigKey<>("Advanced", Integer.class, "external.network.stats.interval", "300",
+            "Interval (in seconds) to report external network statistics.", true);
+
+    ConfigKey<Integer> NetworkIPv6SearchRetryMax = new ConfigKey<>("Network", Integer.class, "network.ipv6.search.retry.max", "10000",
+            "The maximum number of retrying times to search for an available IPv6 address in the table", true);
+
     /**
      * Lists IP addresses that belong to VirtualNetwork VLANs
      *

diff --git a/api/src/main/java/com/cloud/network/NetworkService.java b/api/src/main/java/com/cloud/network/NetworkService.java
@@ -84,6 +84,36 @@
             "allow.end.users.to.specify.vr.mtu", "false", "Allow end Users to specify VR MTU",
             true, ConfigKey.Scope.Zone);
 
+    ConfigKey<Integer> GuestVlanBits = new ConfigKey<>("Network", Integer.class, "guest.vlan.bits", "12",
+            "The number of bits to reserve for the VLAN identifier in the guest subnet.", true);
+
+    ConfigKey<Integer> MaxNumberOfSecondaryIPsPerNIC = new ConfigKey<>("Network", Integer.class,
+            "vm.network.nic.max.secondary.ipaddresses", "10",
+            "Specify the number of secondary ip addresses per nic per vm. Default value 10 is used, if not specified.", true);
+
+    ConfigKey<Integer> NetworkGuestCidrLimit = new ConfigKey<>("Network", Integer.class, "network.guest.cidr.limit", "22",
+            "size limit for guest cidr; can't be less than this value", true);
+
+    ConfigKey<String> XenServerPublicNetwork = new ConfigKey<>("Hidden", String.class,
+            "xenserver.public.network.device", null,
+            "[ONLY IF THE PUBLIC NETWORK IS ON A DEDICATED NIC]:The network name label of the physical device dedicated to the public network on a XenServer host", true);
+
+    ConfigKey<String> XenServerGuestNetwork = new ConfigKey<>("Hidden", String.class,
+            "xenserver.guest.network.device", null,
+            "Specify for guest network name label", true);
+
+    ConfigKey<String> XenServerStorageNetwork1 = new ConfigKey<>("Hidden", String.class,
+            "xenserver.storage.network.device1", null,
+            "Specify when there are storage networks", true);
+
+    ConfigKey<String> XenServerStorageNetwork2 = new ConfigKey<>("Hidden", String.class,
+            "xenserver.storage.network.device2", null,
+            "Specify when there are storage networks", true);
+
+    ConfigKey<String> XenServerPrivateNetwork = new ConfigKey<>("Hidden", String.class,
+            "xenserver.private.network.device", null,
+            "Specify when the private network name is different", true);
+
     List<? extends Network> getIsolatedNetworksOwnedByAccountInZone(long zoneId, Account owner);
 
     IpAddress allocateIP(Account ipOwner, long zoneId, Long networkId, Boolean displayIp, String ipaddress) throws ResourceAllocationException, InsufficientAddressCapacityException,

diff --git a/api/src/main/java/com/cloud/network/NetworkUsageService.java b/api/src/main/java/com/cloud/network/NetworkUsageService.java
@@ -21,12 +21,22 @@
 import org.apache.cloudstack.api.command.admin.usage.AddTrafficMonitorCmd;
 import org.apache.cloudstack.api.command.admin.usage.DeleteTrafficMonitorCmd;
 import org.apache.cloudstack.api.command.admin.usage.ListTrafficMonitorsCmd;
+import org.apache.cloudstack.framework.config.ConfigKey;
 
 import com.cloud.host.Host;
 import com.cloud.utils.component.Manager;
 
 public interface NetworkUsageService extends Manager {
 
+    ConfigKey<Integer> DirectNetworkStatsInterval = new ConfigKey<>("Usage", Integer.class, "direct.network.stats.interval", "86400",
+            "Interval (in seconds) to collect stats from Traffic Monitor", true);
+
+    ConfigKey<String> TrafficSentinelIncludeZones = new ConfigKey<>("Usage", String.class, "traffic.sentinel.include.zones", "EXTERNAL",
+            "Traffic going into specified list of zones is metered. For metering all traffic leave this parameter empty", true);
+
+    ConfigKey<String> TrafficSentinelExcludeZones = new ConfigKey<>("Usage", String.class, "traffic.sentinel.exclude.zones", "",
+            "Traffic going into specified list of zones is not metered.", true);
+
     Host addTrafficMonitor(AddTrafficMonitorCmd cmd);
 
     boolean deleteTrafficMonitor(DeleteTrafficMonitorCmd cmd);

diff --git a/api/src/main/java/com/cloud/network/vpn/RemoteAccessVpnService.java b/api/src/main/java/com/cloud/network/vpn/RemoteAccessVpnService.java
@@ -20,6 +20,7 @@
 
 import org.apache.cloudstack.api.command.user.vpn.ListRemoteAccessVpnsCmd;
 import org.apache.cloudstack.api.command.user.vpn.ListVpnUsersCmd;
+import org.apache.cloudstack.framework.config.ConfigKey;
 
 import com.cloud.exception.NetworkRuleConflictException;
 import com.cloud.exception.ResourceUnavailableException;
@@ -31,6 +32,12 @@
 public interface RemoteAccessVpnService {
     static final String RemoteAccessVpnClientIpRangeCK = "remote.access.vpn.client.iprange";
 
+    ConfigKey<Integer> RemoteAccessVpnPskLength = new ConfigKey<>("Network", Integer.class, "remote.access.vpn.psk.length", "24",
+            "The length of the ipsec preshared key (minimum 8, maximum 256)", true);
+
+    ConfigKey<Integer> RemoteAccessVpnUserLimit = new ConfigKey<>("Network", Integer.class, "remote.access.vpn.user.limit", "8",
+            "The maximum number of VPN users that can be created per account", true);
+
     RemoteAccessVpn createRemoteAccessVpn(long vpnServerAddressId, String ipRange, boolean openFirewall, Boolean forDisplay) throws NetworkRuleConflictException;
 
     boolean destroyRemoteAccessVpnForIp(long ipId, Account caller, boolean forceCleanup) throws ResourceUnavailableException;

diff --git a/api/src/main/java/com/cloud/storage/VolumeApiService.java b/api/src/main/java/com/cloud/storage/VolumeApiService.java
@@ -61,6 +61,18 @@ public interface VolumeApiService {
             true,
             ConfigKey.Scope.Zone);
 
+    ConfigKey<Integer> CopyVolumeWait = new ConfigKey<>("Storage", Integer.class, "copy.volume.wait", "10800",
+            "In second, timeout for copy volume command", true);
+
+    ConfigKey<Integer> CreateVolumeFromSnapshotWait = new ConfigKey<>("Storage", Integer.class, "create.volume.from.snapshot.wait", "10800",
+            "In second, timeout for creating volume from snapshot", true);
+
+    ConfigKey<Long> MaxUploadVolumeSize = new ConfigKey<>("Storage", Long.class, "storage.max.volume.upload.size", "500",
+            "The maximum size for a uploaded volume(in GB).", true);
+
+    ConfigKey<Integer> StoragePoolMaxWaitSeconds = new ConfigKey<>("Storage", Integer.class, "storage.pool.max.waitseconds", "3600",
+            "Timeout (in seconds) to synchronize storage pool operations.", true);
+
     /**
      * Creates the database object for a volume based on the given criteria
      *

diff --git a/api/src/main/java/com/cloud/user/ResourceLimitService.java b/api/src/main/java/com/cloud/user/ResourceLimitService.java
@@ -36,7 +36,7 @@

    static final ConfigKey<Long> MaxAccountSecondaryStorage = new ConfigKey<>("Account Defaults", Long.class, "max.account.secondary.storage", "400",
            "The default maximum secondary storage space (in GiB) that can be used for an Account", false);
    static final ConfigKey<Long> MaxProjectSecondaryStorage = new ConfigKey<>("Project Defaults", Long.class, "max.project.secondary.storage", "400",
            "The default maximum secondary storage space (in GiB) that can be used for a project", false);
    static final ConfigKey<Long> ResourceCountCheckInterval = new ConfigKey<>("Advanced", Long.class, "resourcecount.check.interval", "300",
            "Time (in seconds) to wait before running resource recalculation and fixing tasks like stale resource reservation cleanup" +
@@ -49,7 +49,7 @@
            "A comma-separated list of tags for storage resource limits", true);
    static final ConfigKey<Long> DefaultMaxAccountProjects = new ConfigKey<>("Account Defaults",Long.class,"max.account.projects","10",
                "The default maximum number of projects that can be created for an account",false);
    static final ConfigKey<Long> DefaultMaxDomainProjects = new ConfigKey<>("Domain Defaults",Long.class,"max.domain.projects","50",
                        "The default maximum number of projects that can be created for a domain",false);
    static final ConfigKey<Long> DefaultMaxAccountGpus = new ConfigKey<>("Account Defaults",Long.class,"max.account.gpus","20",
            "The default maximum number of GPU devices that can be used for an account", false);
@@ -58,6 +58,71 @@
     static final ConfigKey<Long> DefaultMaxProjectGpus = new ConfigKey<>("Project Defaults",Long.class,"max.project.gpus","20",
             "The default maximum number of GPU devices that can be used for a project", false);
 
+    static final ConfigKey<Long> DefaultMaxAccountUserVms = new ConfigKey<>("Account Defaults", Long.class, "max.account.user.vms", "20",
+            "The default maximum number of user VMs that can be deployed for an account", false);
+    static final ConfigKey<Long> DefaultMaxAccountPublicIPs = new ConfigKey<>("Account Defaults", Long.class, "max.account.public.ips", "20",
+            "The default maximum number of public IPs that can be consumed by an account", false);
+    static final ConfigKey<Long> DefaultMaxAccountTemplates = new ConfigKey<>("Account Defaults", Long.class, "max.account.templates", "20",
+            "The default maximum number of Templates that can be deployed for an account", false);
+    static final ConfigKey<Long> DefaultMaxAccountSnapshots = new ConfigKey<>("Account Defaults", Long.class, "max.account.snapshots", "20",
+            "The default maximum number of snapshots that can be created for an account", false);
+    static final ConfigKey<Long> DefaultMaxAccountVolumes = new ConfigKey<>("Account Defaults", Long.class, "max.account.volumes", "20",
+            "The default maximum number of volumes that can be created for an account", false);
+    static final ConfigKey<Long> DefaultMaxAccountNetworks = new ConfigKey<>("Account Defaults", Long.class, "max.account.networks", "20",
+            "The default maximum number of networks that can be created for an account", false);
+    static final ConfigKey<Long> DefaultMaxAccountVpcs = new ConfigKey<>("Account Defaults", Long.class, "max.account.vpcs", "20",
+            "The default maximum number of vpcs that can be created for an account", false);
+    static final ConfigKey<Long> DefaultMaxAccountCpus = new ConfigKey<>("Account Defaults", Long.class, "max.account.cpus", "40",
+            "The default maximum number of cpu cores that can be used for an account", false);
+    static final ConfigKey<Long> DefaultMaxAccountMemory = new ConfigKey<>("Account Defaults", Long.class, "max.account.memory", "40960",
+            "The default maximum memory (in MB) that can be used for an account", false);
+    static final ConfigKey<Long> DefaultMaxAccountPrimaryStorage = new ConfigKey<>("Account Defaults", Long.class, "max.account.primary.storage", "200",
+            "The default maximum primary storage space (in GiB) that can be used for an account", false);
+
+    static final ConfigKey<Long> DefaultMaxDomainUserVms = new ConfigKey<>("Domain Defaults", Long.class, "max.domain.user.vms", "40",
+            "The default maximum number of user Instances that can be deployed for a domain", false);
+    static final ConfigKey<Long> DefaultMaxDomainPublicIPs = new ConfigKey<>("Domain Defaults", Long.class, "max.domain.public.ips", "40",
+            "The default maximum number of public IPs that can be consumed by a domain", false);
+    static final ConfigKey<Long> DefaultMaxDomainTemplates = new ConfigKey<>("Domain Defaults", Long.class, "max.domain.templates", "40",
+            "The default maximum number of Templates that can be deployed for a domain", false);
+    static final ConfigKey<Long> DefaultMaxDomainSnapshots = new ConfigKey<>("Domain Defaults", Long.class, "max.domain.snapshots", "40",
+            "The default maximum number of Snapshots that can be created for a domain", false);
+    static final ConfigKey<Long> DefaultMaxDomainVolumes = new ConfigKey<>("Domain Defaults", Long.class, "max.domain.volumes", "40",
+            "The default maximum number of Volumes that can be created for a domain", false);
+    static final ConfigKey<Long> DefaultMaxDomainNetworks = new ConfigKey<>("Domain Defaults", Long.class, "max.domain.networks", "40",
+            "The default maximum number of Networks that can be created for a domain", false);
+    static final ConfigKey<Long> DefaultMaxDomainVpcs = new ConfigKey<>("Domain Defaults", Long.class, "max.domain.vpcs", "40",
+            "The default maximum number of VPCs that can be created for a domain", false);
+    static final ConfigKey<Long> DefaultMaxDomainCpus = new ConfigKey<>("Domain Defaults", Long.class, "max.domain.cpus", "80",
+            "The default maximum number of CPU cores that can be used for a domain", false);
+    static final ConfigKey<Long> DefaultMaxDomainMemory = new ConfigKey<>("Domain Defaults", Long.class, "max.domain.memory", "81920",
+            "The default maximum memory (in MB) that can be used for a domain", false);
+    static final ConfigKey<Long> DefaultMaxDomainPrimaryStorage = new ConfigKey<>("Domain Defaults", Long.class, "max.domain.primary.storage", "400",
+            "The default maximum primary storage space (in GiB) that can be used for a domain", false);
+    static final ConfigKey<Long> DefaultMaxDomainSecondaryStorage = new ConfigKey<>("Domain Defaults", Long.class, "max.domain.secondary.storage", "800",
+            "The default maximum secondary storage space (in GiB) that can be used for a domain", false);
+
+    static final ConfigKey<Long> DefaultMaxProjectUserVms = new ConfigKey<>("Project Defaults", Long.class, "max.project.user.vms", "20",
+            "The default maximum number of user VMs that can be deployed for a project", false);
+    static final ConfigKey<Long> DefaultMaxProjectPublicIPs = new ConfigKey<>("Project Defaults", Long.class, "max.project.public.ips", "20",
+            "The default maximum number of public IPs that can be consumed by a project", false);
+    static final ConfigKey<Long> DefaultMaxProjectTemplates = new ConfigKey<>("Project Defaults", Long.class, "max.project.templates", "20",
+            "The default maximum number of Templates that can be deployed for a project", false);
+    static final ConfigKey<Long> DefaultMaxProjectSnapshots = new ConfigKey<>("Project Defaults", Long.class, "max.project.snapshots", "20",
+            "The default maximum number of snapshots that can be created for a project", false);
+    static final ConfigKey<Long> DefaultMaxProjectVolumes = new ConfigKey<>("Project Defaults", Long.class, "max.project.volumes", "20",
+            "The default maximum number of volumes that can be created for a project", false);
+    static final ConfigKey<Long> DefaultMaxProjectNetworks = new ConfigKey<>("Project Defaults", Long.class, "max.project.networks", "20",
+            "The default maximum number of networks that can be created for a project", false);
+    static final ConfigKey<Long> DefaultMaxProjectVpcs = new ConfigKey<>("Project Defaults", Long.class, "max.project.vpcs", "20",
+            "The default maximum number of vpcs that can be created for a project", false);
+    static final ConfigKey<Long> DefaultMaxProjectCpus = new ConfigKey<>("Project Defaults", Long.class, "max.project.cpus", "40",
+            "The default maximum number of cpu cores that can be used for a project", false);
+    static final ConfigKey<Long> DefaultMaxProjectMemory = new ConfigKey<>("Project Defaults", Long.class, "max.project.memory", "40960",
+            "The default maximum memory (in MB) that can be used for a project", false);
+    static final ConfigKey<Long> DefaultMaxProjectPrimaryStorage = new ConfigKey<>("Project Defaults", Long.class, "max.project.primary.storage", "200",
+            "The default maximum primary storage space (in GiB) that can be used for a project", false);
+
     static final List<ResourceType> HostTagsSupportingTypes = List.of(ResourceType.user_vm, ResourceType.cpu, ResourceType.memory, ResourceType.gpu);
     static final List<ResourceType> StorageTagsSupportingTypes = List.of(ResourceType.volume, ResourceType.primary_storage);
 

diff --git a/api/src/main/java/org/apache/cloudstack/usage/UsageService.java b/api/src/main/java/org/apache/cloudstack/usage/UsageService.java
@@ -20,11 +20,31 @@
 import org.apache.cloudstack.api.command.admin.usage.GenerateUsageRecordsCmd;
 import org.apache.cloudstack.api.command.admin.usage.ListUsageRecordsCmd;
 import org.apache.cloudstack.api.command.admin.usage.RemoveRawUsageRecordsCmd;
+import org.apache.cloudstack.framework.config.ConfigKey;
 
 import java.util.List;
 import java.util.TimeZone;
 
 public interface UsageService {
+
+    ConfigKey<String> UsageAggregationTimezone = new ConfigKey<>("Usage", String.class, "usage.aggregation.timezone", "GMT",
+            "The timezone to use for usage stats aggregation", true);
+
+    ConfigKey<String> UsageExecutionTimezone = new ConfigKey<>("Usage", String.class, "usage.execution.timezone", null,
+            "The timezone to use for usage job execution time", true);
+
+    ConfigKey<Integer> UsageSanityCheckInterval = new ConfigKey<>("Usage", Integer.class, "usage.sanity.check.interval", null,
+            "Interval (in days) to check sanity of usage data. To disable set it to 0 or negative.", true);
+
+    ConfigKey<Integer> UsageStatsJobAggregationRange = new ConfigKey<>("Usage", Integer.class, "usage.stats.job.aggregation.range", "1440",
+            "The range of time for aggregating the user statistics specified in minutes (e.g. 1440 for daily, 60 for hourly.", true);
+
+    ConfigKey<String> UsageStatsJobExecTime = new ConfigKey<>("Usage", String.class, "usage.stats.job.exec.time", "00:15",
+            "The time at which the usage statistics aggregation job will run as an HH24:MM time, e.g. 00:30 to run at 12:30am.", true);
+
+    ConfigKey<Boolean> EnableUsageServer = new ConfigKey<>("Usage", Boolean.class, "enable.usage.server", "true",
+            "Flag for enabling usage", true);
+
     /**
      * Generate Billing Records from the last time it was generated to the
      * time specified.