declare and register ConfigKeys for all remaining Config enum entries

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.

api/src/main/java/com/cloud/network/NetworkModel.java

@@ -97,6 +97,25 @@ public interface NetworkModel {
     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
      *

api/src/main/java/com/cloud/network/NetworkService.java

@@ -84,6 +84,36 @@ public interface NetworkService {
             "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,

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);

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;

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
      *

api/src/main/java/com/cloud/user/ResourceLimitService.java

@@ -58,6 +58,71 @@ public interface ResourceLimitService {
     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);
 

api/src/main/java/org/apache/cloudstack/usage/UsageService.java

@@ -20,11 +20,34 @@
 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);
+
+    ConfigKey<Boolean> UsageSnapshotVirtualSizeSelect = new ConfigKey<>("Usage", Boolean.class, "usage.snapshot.virtualsize.select", "false",
+            "Set the value to true if snapshot usage need to consider virtual size, else physical size is considered", true);
+
     /**
      * Generate Billing Records from the last time it was generated to the
      * time specified.