From 2c8bbb4f01a32d6573a2a7d3a14c1ad4fe3deeb0 Mon Sep 17 00:00:00 2001 From: chandra1-n Date: Tue, 4 Apr 2023 00:13:13 +0530 Subject: [PATCH] GCP all parameters added GCP all parameters added --- .../GcpElastigroupHealthCheckTypeEnum.java | 38 + .../GcpElastigroupProvisioningModelEnum.java | 38 + .../gcp/ElastigroupUsageExampleGcp.java | 29 +- ...iElastigroupAutoscaleConfigurationGcp.java | 107 ++ ...ApiElastigroupBackendServiceConfigGcp.java | 46 + .../gcp/ApiElastigroupBackendServicesGcp.java | 83 ++ .../ApiElastigroupCustomInstanceTypesGcp.java | 59 ++ .../api/gcp/ApiElastigroupDockerSwarmGcp.java | 61 ++ .../ApiElastigroupDownSpecificationGcp.java | 46 + .../model/api/gcp/ApiElastigroupGcp.java | 61 +- .../ApiElastigroupGkeConfigurationGcp.java | 93 ++ .../model/api/gcp/ApiElastigroupGpuGcp.java | 57 + ...piElastigroupHeadroomSpecificationGcp.java | 70 ++ .../api/gcp/ApiElastigroupHealthGcp.java | 84 ++ .../api/gcp/ApiElastigroupMetadataGcp.java | 54 + .../api/gcp/ApiElastigroupNamedPortsGcp.java | 56 + ...iElastigroupPreferredInstanceTypesGcp.java | 60 ++ .../gcp/ApiElastigroupScalingActionGcp.java | 61 ++ ...ApiElastigroupScalingConfigurationGcp.java | 62 ++ .../ApiElastigroupScalingDimensionGcp.java | 60 ++ .../gcp/ApiElastigroupScalingPolicyGcp.java | 230 ++++ ...stigroupScheduleTasksConfigurationGcp.java | 122 +++ .../api/gcp/ApiElastigroupSchedulingGcp.java | 47 + ...ElastigroupThirdPartiesIntegrationGcp.java | 61 ++ .../model/api/gcp/ApiGroupComputeGcp.java | 39 + .../model/api/gcp/ApiInstanceTypesGcp.java | 32 +- .../api/gcp/ApiLaunchSpecificationGcp.java | 94 +- .../sdkjava/model/api/gcp/ApiStrategyGcp.java | 30 +- .../ElastigroupAutoscaleConfigurationGcp.java | 140 +++ .../ElastigroupBackendServiceConfigGcp.java | 64 ++ .../gcp/ElastigroupBackendServicesGcp.java | 116 ++ .../gcp/ElastigroupComputeGcp.java | 116 +- .../ElastigroupCustomInstanceTypesGcp.java | 82 ++ .../gcp/ElastigroupDockerSwarmGcp.java | 84 ++ .../gcp/ElastigroupDownSpecificationGcp.java | 60 ++ .../bl/elastigroup/gcp/ElastigroupGcp.java | 72 +- .../gcp/ElastigroupGkeConfigurationGcp.java | 125 +++ .../bl/elastigroup/gcp/ElastigroupGpuGcp.java | 79 ++ .../ElastigroupHeadroomSpecificationGcp.java | 98 ++ .../elastigroup/gcp/ElastigroupHealthGcp.java | 117 ++ .../gcp/ElastigroupInstanceTypesGcp.java | 49 +- .../ElastigroupLaunchSpecificationGcp.java | 133 +++ .../gcp/ElastigroupMetadataGcp.java | 76 ++ .../gcp/ElastigroupNamedPortsGcp.java | 79 ++ .../ElastigroupPreferredInstanceTypesGcp.java | 85 ++ .../gcp/ElastigroupScalingActionGcp.java | 84 ++ .../ElastigroupScalingConfigurationGcp.java | 86 ++ .../gcp/ElastigroupScalingDimensionGcp.java | 84 ++ .../gcp/ElastigroupScalingPolicyGcp.java | 307 ++++++ ...stigroupScheduleTasksConfigurationGcp.java | 166 +++ .../gcp/ElastigroupSchedulingGcp.java | 65 ++ .../gcp/ElastigroupStrategyGcp.java | 33 +- ...ElastigroupThirdPartiesIntegrationGcp.java | 84 ++ .../gcp/ElastigroupConverterGcp.java | 998 +++++++++++++++++- 54 files changed, 5245 insertions(+), 117 deletions(-) create mode 100644 src/main/java/com/spotinst/sdkjava/enums/gcp/GcpElastigroupHealthCheckTypeEnum.java create mode 100644 src/main/java/com/spotinst/sdkjava/enums/gcp/GcpElastigroupProvisioningModelEnum.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupAutoscaleConfigurationGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupBackendServiceConfigGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupBackendServicesGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupCustomInstanceTypesGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupDockerSwarmGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupDownSpecificationGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupGkeConfigurationGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupGpuGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupHeadroomSpecificationGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupHealthGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupMetadataGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupNamedPortsGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupPreferredInstanceTypesGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupScalingActionGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupScalingConfigurationGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupScalingDimensionGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupScalingPolicyGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupScheduleTasksConfigurationGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupSchedulingGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupThirdPartiesIntegrationGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupAutoscaleConfigurationGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupBackendServiceConfigGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupBackendServicesGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupCustomInstanceTypesGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupDockerSwarmGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupDownSpecificationGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupGkeConfigurationGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupGpuGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupHeadroomSpecificationGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupHealthGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupMetadataGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupNamedPortsGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupPreferredInstanceTypesGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupScalingActionGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupScalingConfigurationGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupScalingDimensionGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupScalingPolicyGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupScheduleTasksConfigurationGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupSchedulingGcp.java create mode 100644 src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupThirdPartiesIntegrationGcp.java diff --git a/src/main/java/com/spotinst/sdkjava/enums/gcp/GcpElastigroupHealthCheckTypeEnum.java b/src/main/java/com/spotinst/sdkjava/enums/gcp/GcpElastigroupHealthCheckTypeEnum.java new file mode 100644 index 000000000..3f34af595 --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/enums/gcp/GcpElastigroupHealthCheckTypeEnum.java @@ -0,0 +1,38 @@ +package com.spotinst.sdkjava.enums.gcp; + +import java.util.logging.Logger; + +public enum GcpElastigroupHealthCheckTypeEnum { + + K8S_NODE("K8S_NODE"), + BACKEND_SERVICE("BACKEND_SERVICE"); + + private String name; + + GcpElastigroupHealthCheckTypeEnum(String name) { + this.name = name; + } + + private static final Logger LOGGER = LoggerFactory.getLogger(GcpElastigroupHealthCheckTypeEnum.class); + + public static GcpElastigroupHealthCheckTypeEnum fromName(String name) { + GcpElastigroupHealthCheckTypeEnum retVal = null; + + for (GcpElastigroupHealthCheckTypeEnum instanceStateEnum : GcpElastigroupHealthCheckTypeEnum.values()) { + if (StringUtils.equalsIgnoreCase(name, instanceStateEnum.name)) { + retVal = instanceStateEnum; + break; + } + } + + if (retVal == null) { + LOGGER.error(String.format("Tried to create Health Check Type Enum for: %s, but we don't support such type", + name)); + } + return retVal; + } + + public String getName() { + return name; + } +} diff --git a/src/main/java/com/spotinst/sdkjava/enums/gcp/GcpElastigroupProvisioningModelEnum.java b/src/main/java/com/spotinst/sdkjava/enums/gcp/GcpElastigroupProvisioningModelEnum.java new file mode 100644 index 000000000..ef142651b --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/enums/gcp/GcpElastigroupProvisioningModelEnum.java @@ -0,0 +1,38 @@ +package com.spotinst.sdkjava.enums.gcp; + +import java.util.logging.Logger; + +public enum GcpElastigroupProvisioningModelEnum { + + PREEMPTIBLE("PREEMPTIBLE"), + SPOT("SPOT"); + + private String name; + + GcpElastigroupProvisioningModelEnum(String name) { + this.name = name; + } + + private static final Logger LOGGER = LoggerFactory.getLogger(GcpElastigroupProvisioningModelEnum.class); + + public static GcpElastigroupProvisioningModelEnum fromName(String name) { + GcpElastigroupProvisioningModelEnum retVal = null; + + for (GcpElastigroupProvisioningModelEnum provisioningModelEnum : GcpElastigroupProvisioningModelEnum.values()) { + if (StringUtils.equalsIgnoreCase(name, provisioningModelEnum.name)) { + retVal = provisioningModelEnum; + break; + } + } + + if (retVal == null) { + LOGGER.error(String.format("Tried to create Health Check Type Enum for: %s, but we don't support such type", + name)); + } + return retVal; + } + + public String getName() { + return name; + } +} diff --git a/src/main/java/com/spotinst/sdkjava/example/elastigroup/gcp/ElastigroupUsageExampleGcp.java b/src/main/java/com/spotinst/sdkjava/example/elastigroup/gcp/ElastigroupUsageExampleGcp.java index 56880ebe0..10cee6b17 100644 --- a/src/main/java/com/spotinst/sdkjava/example/elastigroup/gcp/ElastigroupUsageExampleGcp.java +++ b/src/main/java/com/spotinst/sdkjava/example/elastigroup/gcp/ElastigroupUsageExampleGcp.java @@ -3,6 +3,7 @@ import com.spotinst.sdkjava.SpotinstClient; import com.spotinst.sdkjava.enums.GroupActiveInstanceStatusEnumGcp; import com.spotinst.sdkjava.enums.PerformAtEnumGcp; +import com.spotinst.sdkjava.enums.gcp.GcpElastigroupHealthCheckTypeEnum; import com.spotinst.sdkjava.model.*; import com.spotinst.sdkjava.model.bl.elastigroup.gcp.*; import com.spotinst.sdkjava.model.requests.elastigroup.gcp.ElastigroupCreationRequestGcp; @@ -119,6 +120,11 @@ private static String createElastigroup(SpotinstElastigroupClientGcp client) { List subnetsGcpList = new ArrayList<>(); subnetsGcpList.add(subnetsGcp); + //build health + ElastigroupHealthGcp.Builder elastigroupHealthBuilder = ElastigroupHealthGcp.Builder.get(); + ElastigroupHealthGcp healthGcp = elastigroupHealthBuilder.setHealthCheckType(GcpElastigroupHealthCheckTypeEnum.BACKEND_SERVICE) + .setAutoHealing(false).setGracePeriod(300).setUnhealthyDuration(160).build(); + //build launch specification ElastigroupLaunchSpecificationGcp.Builder ElastigroupLaunchSpecificationGcpBuilder = ElastigroupLaunchSpecificationGcp.Builder.get(); @@ -135,7 +141,8 @@ private static String createElastigroup(SpotinstElastigroupClientGcp client) { ElastigroupComputeGcp computeConfigurationGcp = ElastigroupComputeConfigurationGcpBuilder .setAvailabilityZones(AvailabilityZonesList).setInstanceTypes(instanceTypesGcp) - .setLaunchSpecification(launchSpecificationGcp).setSubnets(subnetsGcpList).build(); + .setLaunchSpecification(launchSpecificationGcp).setSubnets(subnetsGcpList) + .setHealth(healthGcp).build(); //Build group capacity ElastigroupCapacityGcp.Builder capacityBuilder = @@ -166,6 +173,23 @@ private static String createElastigroup(SpotinstElastigroupClientGcp client) { .setPreemptiblePercentage(100) .setRevertToPreemptible(revertToPreemptibleGcp).build(); + //build schedulingTasks + ElastigroupScheduleTasksConfigurationGcp.Builder taskBuilder = ElastigroupScheduleTasksConfigurationGcp.Builder.get(); + + ElastigroupScheduleTasksConfigurationGcp tasksGcp = taskBuilder.setCronExpression("8 10 * * *") + .setIsEnabled(true).setMaxCapacity(10).setMinCapacity(1).setTargetCapacity(5).setTaskType("setCapacity") + .build(); + + List tasksGcpList = new ArrayList<>(); + tasksGcpList.add(tasksGcp); + + //build scheduling + ElastigroupSchedulingGcp.Builder schedulingBuilder = + ElastigroupSchedulingGcp.Builder.get(); + + ElastigroupSchedulingGcp schedulingGcp= + schedulingBuilder.setTasks(tasksGcpList).build(); + //build elastigroup gcp ElastigroupGcp.Builder ElastigroupGcpBuilder = ElastigroupGcp.Builder.get(); ElastigroupGcp elastigroupGcp = @@ -173,7 +197,8 @@ private static String createElastigroup(SpotinstElastigroupClientGcp client) { .setDescription("spotinst-automation") .setCapacity(capacity) .setCompute(computeConfigurationGcp) - .setStrategy(strategyConfigurationGcp).build(); + .setStrategy(strategyConfigurationGcp) + .setScheduling(schedulingGcp).build(); // Build gcp elastigroup creation request ElastigroupCreationRequestGcp.Builder ElastigroupCreationRequestGcpBuilder = diff --git a/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupAutoscaleConfigurationGcp.java b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupAutoscaleConfigurationGcp.java new file mode 100644 index 000000000..61ccb3171 --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupAutoscaleConfigurationGcp.java @@ -0,0 +1,107 @@ +package com.spotinst.sdkjava.model.api.gcp; + + +import com.fasterxml.jackson.annotation.JsonFilter; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.spotinst.sdkjava.client.rest.IPartialUpdateEntity; + +import java.util.HashSet; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +@JsonFilter("PartialUpdateEntityFilter") +public class ApiElastigroupAutoscaleConfigurationGcp implements IPartialUpdateEntity { + + @JsonIgnore + private Set isSet; + private Integer cooldown; + private ApiElastigroupDownSpecificationGcp down; + private ApiElastigroupHeadroomSpecificationGcp headroom; + private Boolean isAutoConfig; + private Boolean isEnabled; + + public ApiElastigroupAutoscaleConfigurationGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public Integer getCooldown() { + return cooldown; + } + + public ApiElastigroupDownSpecificationGcp getDown() { + return down; + } + + public void setDown(ApiElastigroupDownSpecificationGcp down) { + isSet.add("down"); + this.down = down; + } + + public ApiElastigroupHeadroomSpecificationGcp getHeadroom() { + return headroom; + } + + public void setHeadroom(ApiElastigroupHeadroomSpecificationGcp headroom) { + isSet.add("headroom"); + this.headroom = headroom; + } + + public void setCooldown(Integer cooldown) { + isSet.add("cooldown"); + this.cooldown = cooldown; + } + + public Boolean getIsAutoConfig() { + return isAutoConfig; + } + + public void setIsAutoConfig(Boolean isAutoConfig) { + isSet.add("isAutoConfig"); + this.isAutoConfig = isAutoConfig; + } + + public Boolean getIsEnabled() { + return isEnabled; + } + + public void setIsEnabled(Boolean isEnabled) { + isSet.add("isEnabled"); + this.isEnabled = isEnabled; + } + + @JsonIgnore + public boolean isIsEnabledSet() { + return isSet.contains("isEnabled"); + } + + @JsonIgnore + public boolean isCooldownSet() { + return isSet.contains("cooldown"); + } + + @JsonIgnore + public boolean isDownSet() { + return isSet.contains("down"); + } + + @JsonIgnore + public boolean isHeadroomSet() { + return isSet.contains("headroom"); + } + + @JsonIgnore + public boolean isIsAutoConfigSet() { + return isSet.contains("isAutoConfig"); + } +} diff --git a/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupBackendServiceConfigGcp.java b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupBackendServiceConfigGcp.java new file mode 100644 index 000000000..67b87f1c8 --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupBackendServiceConfigGcp.java @@ -0,0 +1,46 @@ +package com.spotinst.sdkjava.model.api.gcp; + +import com.fasterxml.jackson.annotation.JsonFilter; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.spotinst.sdkjava.client.rest.IPartialUpdateEntity; + +import java.util.HashSet; +import java.util.List; +import java.util.Set; + + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +@JsonFilter("PartialUpdateEntityFilter") +public class ApiElastigroupBackendServiceConfigGcp implements IPartialUpdateEntity { + + @JsonIgnore + private Set isSet; + private List backendServices; + + public ApiElastigroupBackendServiceConfigGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public List getBackendServices() { + return backendServices; + } + + public void setBackendServices(List backendServices) { + isSet.add("backendServices"); + this.backendServices = backendServices; + } + + @JsonIgnore + public boolean isBackendServicesSet() { return isSet.contains("backendServices"); } +} diff --git a/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupBackendServicesGcp.java b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupBackendServicesGcp.java new file mode 100644 index 000000000..6e0dfe3d7 --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupBackendServicesGcp.java @@ -0,0 +1,83 @@ +package com.spotinst.sdkjava.model.api.gcp; + +import com.fasterxml.jackson.annotation.JsonFilter; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.spotinst.sdkjava.client.rest.IPartialUpdateEntity; + +import java.util.HashSet; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +@JsonFilter("PartialUpdateEntityFilter") +public class ApiElastigroupBackendServicesGcp implements IPartialUpdateEntity { + + @JsonIgnore + private Set isSet; + private String backendServiceName; + private String locationType; + private ApiElastigroupNamedPortsGcp namedPorts; + private String scheme; + + public ApiElastigroupBackendServicesGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public String getBackendServiceName() { + return backendServiceName; + } + + public void setBackendServiceName(String backendServiceName) { + isSet.add("backendServiceName"); + this.backendServiceName = backendServiceName; + } + + public String getLocationType() { + return locationType; + } + + public void setLocationType(String locationType) { + isSet.add("locationType"); + this.locationType = locationType; + } + + public ApiElastigroupNamedPortsGcp getNamedPorts() { + return namedPorts; + } + + public void setNamedPorts(ApiElastigroupNamedPortsGcp namedPorts) { + isSet.add("namedPorts"); + this.namedPorts = namedPorts; + } + + public String getScheme() { + return scheme; + } + + public void setScheme(String scheme) { + isSet.add("scheme"); + this.scheme = scheme; + } + + @JsonIgnore + public boolean isBackendServiceNameSet() { return isSet.contains("backendServiceName"); } + + @JsonIgnore + public boolean isLocationTypeSet() { return isSet.contains("locationType"); } + + @JsonIgnore + public boolean isNamedPortsSet() { return isSet.contains("namedPorts"); } + + @JsonIgnore + public boolean isSchemeSet() { return isSet.contains("scheme"); } +} diff --git a/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupCustomInstanceTypesGcp.java b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupCustomInstanceTypesGcp.java new file mode 100644 index 000000000..b85bba0a1 --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupCustomInstanceTypesGcp.java @@ -0,0 +1,59 @@ +package com.spotinst.sdkjava.model.api.gcp; + +import com.fasterxml.jackson.annotation.JsonFilter; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.spotinst.sdkjava.client.rest.IPartialUpdateEntity; + +import java.util.HashSet; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +@JsonFilter("PartialUpdateEntityFilter") +public class ApiElastigroupCustomInstanceTypesGcp implements IPartialUpdateEntity { + + @JsonIgnore + private Set isSet; + private Integer memoryGiB; + private Integer vCPU; + + public ApiElastigroupCustomInstanceTypesGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public Integer getMemoryGiB() { + return memoryGiB; + } + + public void setMemoryGiB(Integer memoryGiB) { + isSet.add("memoryGiB"); + this.memoryGiB = memoryGiB; + } + + public Integer getVCPU() { + return vCPU; + } + + public void setVCPU(Integer vCPU) { + isSet.add("vCPU"); + this.vCPU = vCPU; + } + + @JsonIgnore + public boolean isMemoryGiBSet() { + return isSet.contains("memoryGiB"); + } + + @JsonIgnore + public boolean isVCPUSet() { return isSet.contains("vCPU"); } +} diff --git a/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupDockerSwarmGcp.java b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupDockerSwarmGcp.java new file mode 100644 index 000000000..e9bb4d789 --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupDockerSwarmGcp.java @@ -0,0 +1,61 @@ +package com.spotinst.sdkjava.model.api.gcp; + +import com.fasterxml.jackson.annotation.JsonFilter; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.spotinst.sdkjava.client.rest.IPartialUpdateEntity; + +import java.util.HashSet; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +@JsonFilter("PartialUpdateEntityFilter") +public class ApiElastigroupDockerSwarmGcp implements IPartialUpdateEntity { + + @JsonIgnore + private Set isSet; + private String masterHost; + private Integer masterPort; + + public ApiElastigroupDockerSwarmGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public String getMasterHost() { + return masterHost; + } + + public void setMasterHost(String masterHost) { + isSet.add("masterHost"); + this.masterHost = masterHost; + } + + public Integer getMasterPort() { + return masterPort; + } + + public void setMasterPort(Integer masterPort) { + isSet.add("masterPort"); + this.masterPort = masterPort; + } + + @JsonIgnore + public boolean isMasterHostSet() { + return isSet.contains("masterHost"); + } + + @JsonIgnore + public boolean isMasterPortSet() { + return isSet.contains("masterPort"); + } +} diff --git a/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupDownSpecificationGcp.java b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupDownSpecificationGcp.java new file mode 100644 index 000000000..ed9bc6074 --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupDownSpecificationGcp.java @@ -0,0 +1,46 @@ +package com.spotinst.sdkjava.model.api.gcp; + +import com.fasterxml.jackson.annotation.JsonFilter; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.spotinst.sdkjava.client.rest.IPartialUpdateEntity; + +import java.util.HashSet; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +@JsonFilter("PartialUpdateEntityFilter") +public class ApiElastigroupDownSpecificationGcp implements IPartialUpdateEntity { + + @JsonIgnore + private Set isSet; + private Integer evaluationPeriods; + + public ApiElastigroupDownSpecificationGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public Integer getEvaluationPeriods() { + return evaluationPeriods; + } + + public void setEvaluationPeriods(Integer evaluationPeriods) { + isSet.add("evaluationPeriods"); + this.evaluationPeriods = evaluationPeriods; + } + + @JsonIgnore + public boolean isEvaluationPeriodsSet() { + return isSet.contains("evaluationPeriods"); + } +} diff --git a/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupGcp.java b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupGcp.java index 7d8dcfb09..274668ca6 100755 --- a/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupGcp.java +++ b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupGcp.java @@ -17,15 +17,18 @@ public class ApiElastigroupGcp implements IPartialUpdateEntity { //region Members @JsonIgnore - private Set isSet; - private String id; - private String name; - private String description; - private ApiCapacityGcp capacity; - private ApiStrategyGcp strategy; - private ApiGroupComputeGcp compute; - private Date createdAt; - private Date updatedAt; + private Set isSet; + private String id; + private String name; + private String description; + private ApiCapacityGcp capacity; + private ApiStrategyGcp strategy; + private ApiGroupComputeGcp compute; + private Date createdAt; + private Date updatedAt; + private ApiElastigroupScalingConfigurationGcp scaling; + private ApiElastigroupSchedulingGcp scheduling; + private ApiElastigroupThirdPartiesIntegrationGcp thirdPartiesIntegration; //endregion //region Constructor @@ -113,6 +116,33 @@ public void setUpdatedAt(Date updatedAt) { isSet.add("updatedAt"); this.updatedAt = updatedAt; } + + public ApiElastigroupScalingConfigurationGcp getScaling() { + return scaling; + } + + public void setScaling(ApiElastigroupScalingConfigurationGcp scaling) { + isSet.add("scaling"); + this.scaling = scaling; + } + + public ApiElastigroupSchedulingGcp getScheduling() { + return scheduling; + } + + public void setScheduling(ApiElastigroupSchedulingGcp scheduling) { + isSet.add("scheduling"); + this.scheduling = scheduling; + } + + public ApiElastigroupThirdPartiesIntegrationGcp getThirdPartiesIntegration() { + return thirdPartiesIntegration; + } + + public void setThirdPartiesIntegration(ApiElastigroupThirdPartiesIntegrationGcp thirdPartiesIntegration) { + isSet.add("thirdPartiesIntegration"); + this.thirdPartiesIntegration = thirdPartiesIntegration; + } //endregion //region isSet methods @@ -163,5 +193,18 @@ public boolean isCreatedAtSet() { public boolean isUpdatedAtSet() { return isSet.contains("updatedAt"); } + + @JsonIgnore + public boolean isScalingSet() { + return isSet.contains("scaling"); + } + + @JsonIgnore + public boolean isSchedulingSet() { return isSet.contains("scheduling"); } + + @JsonIgnore + public boolean isThirdPartiesIntegrationSet() { + return isSet.contains("thirdPartiesIntegration"); + } //endregion } diff --git a/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupGkeConfigurationGcp.java b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupGkeConfigurationGcp.java new file mode 100644 index 000000000..d50a133ed --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupGkeConfigurationGcp.java @@ -0,0 +1,93 @@ +package com.spotinst.sdkjava.model.api.gcp; + + +import com.fasterxml.jackson.annotation.JsonFilter; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.spotinst.sdkjava.client.rest.IPartialUpdateEntity; + +import java.util.HashSet; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +@JsonFilter("PartialUpdateEntityFilter") +public class ApiElastigroupGkeConfigurationGcp implements IPartialUpdateEntity { + + @JsonIgnore + private Set isSet; + private ApiElastigroupAutoscaleConfigurationGcp autoScale; + private Boolean autoUpdate; + private String clusterIdentifier; + private String location; + + + public ApiElastigroupGkeConfigurationGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public ApiElastigroupAutoscaleConfigurationGcp getAutoScale() { + return autoScale; + } + + public void setAutoScale(ApiElastigroupAutoscaleConfigurationGcp autoScale) { + isSet.add("autoScale"); + this.autoScale = autoScale; + } + + public Boolean getAutoUpdate() { + return autoUpdate; + } + + public void setAutoUpdate(Boolean autoUpdate) { + isSet.add("autoUpdate"); + this.autoUpdate = autoUpdate; + } + + public String getClusterIdentifier() { + return clusterIdentifier; + } + + public void setClusterIdentifier(String clusterIdentifier) { + isSet.add("clusterIdentifier"); + this.clusterIdentifier = clusterIdentifier; + } + + public String getLocation() { + return location; + } + + public void setLocation(String location) { + isSet.add("location"); + this.location = location; + } + + @JsonIgnore + public boolean isAutoScaleSet() { + return isSet.contains("autoScale"); + } + + @JsonIgnore + public boolean isAutoUpdateSet() { + return isSet.contains("autoUpdate"); + } + + @JsonIgnore + public boolean isClusterIdentifierSet() { + return isSet.contains("clusterIdentifier"); + } + + @JsonIgnore + public boolean isLocationSet() { + return isSet.contains("location"); + } +} diff --git a/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupGpuGcp.java b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupGpuGcp.java new file mode 100644 index 000000000..3d471ebb1 --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupGpuGcp.java @@ -0,0 +1,57 @@ +package com.spotinst.sdkjava.model.api.gcp; + +import com.fasterxml.jackson.annotation.JsonFilter; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.spotinst.sdkjava.client.rest.IPartialUpdateEntity; + +import java.util.HashSet; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +@JsonFilter("PartialUpdateEntityFilter") +public class ApiElastigroupGpuGcp implements IPartialUpdateEntity { + + @JsonIgnore + private Set isSet; + private Integer count; + private String type; + + public ApiElastigroupGpuGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public Integer getCount() { + return count; + } + + public void setCount(Integer count) { + isSet.add("count"); + this.count = count; + } + + public String getType() { + return type; + } + + public void setType(String type) { + isSet.add("type"); + this.type = type; + } + + @JsonIgnore + public boolean isCountSet() { return isSet.contains("count"); } + + @JsonIgnore + public boolean isTypeSet() { return isSet.contains("type"); } +} diff --git a/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupHeadroomSpecificationGcp.java b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupHeadroomSpecificationGcp.java new file mode 100644 index 000000000..73985fad1 --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupHeadroomSpecificationGcp.java @@ -0,0 +1,70 @@ +package com.spotinst.sdkjava.model.api.gcp; + +import com.fasterxml.jackson.annotation.JsonFilter; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.spotinst.sdkjava.client.rest.IPartialUpdateEntity; + +import java.util.HashSet; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +@JsonFilter("PartialUpdateEntityFilter") +public class ApiElastigroupHeadroomSpecificationGcp implements IPartialUpdateEntity { + + @JsonIgnore + private Set isSet; + private Integer cpuPerUnit; + private Integer memoryPerUnit; + private Integer numOfUnits; + + public ApiElastigroupHeadroomSpecificationGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public Integer getCpuPerUnit() { + return cpuPerUnit; + } + + public void setCpuPerUnit(Integer cpuPerUnit) { + isSet.add("cpuPerUnit"); + this.cpuPerUnit = cpuPerUnit; + } + + public Integer getMemoryPerUnit() { + return memoryPerUnit; + } + + public void setMemoryPerUnit(Integer memoryPerUnit) { + isSet.add("memoryPerUnit"); + this.memoryPerUnit = memoryPerUnit; + } + + public Integer getNumOfUnits() { + return numOfUnits; + } + + public void setNumOfUnits(Integer numOfUnits) { + isSet.add("numOfUnits"); + this.numOfUnits = numOfUnits; + } + + @JsonIgnore + public boolean isCpuPerUnitSet() {return isSet.contains("cpuPerUnit");} + + @JsonIgnore + public boolean isMemoryPerUnitSet() {return isSet.contains("memoryPerUnit");} + + @JsonIgnore + public boolean isNumOfUnitsSet() {return isSet.contains("numOfUnits");} +} diff --git a/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupHealthGcp.java b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupHealthGcp.java new file mode 100644 index 000000000..acceaf2a9 --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupHealthGcp.java @@ -0,0 +1,84 @@ +package com.spotinst.sdkjava.model.api.gcp; + +import com.fasterxml.jackson.annotation.JsonFilter; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.spotinst.sdkjava.client.rest.IPartialUpdateEntity; +import com.spotinst.sdkjava.enums.gcp.GcpElastigroupHealthCheckTypeEnum; + +import java.util.HashSet; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +@JsonFilter("PartialUpdateEntityFilter") +public class ApiElastigroupHealthGcp implements IPartialUpdateEntity { + + @JsonIgnore + private Set isSet; + private Boolean autoHealing; + private Integer gracePeriod; + private GcpElastigroupHealthCheckTypeEnum healthCheckType; + private Integer unhealthyDuration; + + public ApiElastigroupHealthGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public Boolean getAutoHealing() { + return autoHealing; + } + + public void setAutoHealing(Boolean autoHealing) { + isSet.add("autoHealing"); + this.autoHealing = autoHealing; + } + + public Integer getGracePeriod() { + return gracePeriod; + } + + public void setGracePeriod(Integer gracePeriod) { + isSet.add("gracePeriod"); + this.gracePeriod = gracePeriod; + } + + public GcpElastigroupHealthCheckTypeEnum getHealthCheckType() { + return healthCheckType; + } + + public void setHealthCheckType(GcpElastigroupHealthCheckTypeEnum healthCheckType) { + isSet.add("healthCheckType"); + this.healthCheckType = healthCheckType; + } + + public Integer getUnhealthyDuration() { + return unhealthyDuration; + } + + public void setUnhealthyDuration(Integer unhealthyDuration) { + isSet.add("unhealthyDuration"); + this.unhealthyDuration = unhealthyDuration; + } + + @JsonIgnore + public boolean isAutoHealingSet() { return isSet.contains("autoHealing"); } + + @JsonIgnore + public boolean isGracePeriodSet() { return isSet.contains("gracePeriod"); } + + @JsonIgnore + public boolean isHealthCheckTypeSet() { return isSet.contains("healthCheckType"); } + + @JsonIgnore + public boolean isUnhealthyDurationSet() { return isSet.contains("unhealthyDuration"); } +} diff --git a/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupMetadataGcp.java b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupMetadataGcp.java new file mode 100644 index 000000000..2d26c1d1c --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupMetadataGcp.java @@ -0,0 +1,54 @@ +package com.spotinst.sdkjava.model.api.gcp; + +import com.fasterxml.jackson.annotation.JsonFilter; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.spotinst.sdkjava.client.rest.IPartialUpdateEntity; + +import java.util.HashSet; +import java.util.Set; + + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +@JsonFilter("PartialUpdateEntityFilter") +public class ApiElastigroupMetadataGcp implements IPartialUpdateEntity { + + @JsonIgnore + private Set isSet; + private String key; + private String value; + + public ApiElastigroupMetadataGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public String getKey() { return key; } + + public void setKey(String key) { + isSet.add("key"); + this.key = key; + } + + public String getValue() { return value; } + + public void setValue(String value) { + isSet.add("value"); + this.value = value; + } + + @JsonIgnore + public boolean isKeySet() { return isSet.contains("key"); } + + @JsonIgnore + public boolean isValueSet() { return isSet.contains("value"); } +} diff --git a/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupNamedPortsGcp.java b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupNamedPortsGcp.java new file mode 100644 index 000000000..c7b4f2124 --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupNamedPortsGcp.java @@ -0,0 +1,56 @@ +package com.spotinst.sdkjava.model.api.gcp; + +import com.fasterxml.jackson.annotation.JsonFilter; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.spotinst.sdkjava.client.rest.IPartialUpdateEntity; + +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +@JsonFilter("PartialUpdateEntityFilter") +public class ApiElastigroupNamedPortsGcp implements IPartialUpdateEntity { + + @JsonIgnore + private Set isSet; + private String name; + private List ports; + + public ApiElastigroupNamedPortsGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public List getPorts() { + return ports; + } + + public void setPorts(List ports) { + isSet.add("ports"); + this.ports = ports; + } + + public String getName() { return name; } + + public void setName(String name) { + isSet.add("name"); + this.name = name; + } + + @JsonIgnore + public boolean isNameSet() { return isSet.contains("name"); } + + @JsonIgnore + public boolean isPortsSet() { return isSet.contains("ports"); } +} diff --git a/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupPreferredInstanceTypesGcp.java b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupPreferredInstanceTypesGcp.java new file mode 100644 index 000000000..1851f2211 --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupPreferredInstanceTypesGcp.java @@ -0,0 +1,60 @@ +package com.spotinst.sdkjava.model.api.gcp; + +import com.fasterxml.jackson.annotation.JsonFilter; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.spotinst.sdkjava.client.rest.IPartialUpdateEntity; + +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +@JsonFilter("PartialUpdateEntityFilter") +public class ApiElastigroupPreferredInstanceTypesGcp implements IPartialUpdateEntity { + + @JsonIgnore + private Set isSet; + private List preemptible; + private ApiElastigroupCustomInstanceTypesGcp custom; + + public ApiElastigroupPreferredInstanceTypesGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public List getPreemptible() { + return preemptible; + } + + public void setPreemptible(List preemptible) { + isSet.add("preemptible"); + this.preemptible = preemptible; + } + + public ApiElastigroupCustomInstanceTypesGcp getCustom() { + return custom; + } + + public void setCustom(ApiElastigroupCustomInstanceTypesGcp custom) { + isSet.add("custom"); + this.custom = custom; + } + + @JsonIgnore + public boolean isPreemptibleSet() { + return isSet.contains("preemptible"); + } + + @JsonIgnore + public boolean isCustomSet() { return isSet.contains("custom"); } +} diff --git a/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupScalingActionGcp.java b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupScalingActionGcp.java new file mode 100644 index 000000000..79c76b619 --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupScalingActionGcp.java @@ -0,0 +1,61 @@ +package com.spotinst.sdkjava.model.api.gcp; + + +import com.fasterxml.jackson.annotation.JsonFilter; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.spotinst.sdkjava.client.rest.IPartialUpdateEntity; + +import java.util.HashSet; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +@JsonFilter("PartialUpdateEntityFilter") +public class ApiElastigroupScalingActionGcp implements IPartialUpdateEntity { + @JsonIgnore + private Set isSet; + private String type; + private Integer adjustment; + + public ApiElastigroupScalingActionGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public String getType() { + return type; + } + + public void setType(String type) { + isSet.add("type"); + this.type = type; + } + + public Integer getAdjustment() { + return adjustment; + } + + public void setAdjustment(Integer adjustment) { + isSet.add("adjustment"); + this.adjustment = adjustment; + } + + @JsonIgnore + public boolean isTypeSet() { + return isSet.contains("type"); + } + + @JsonIgnore + public boolean isAdjustmentSet() { + return isSet.contains("adjustment"); + } +} diff --git a/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupScalingConfigurationGcp.java b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupScalingConfigurationGcp.java new file mode 100644 index 000000000..b2f51285c --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupScalingConfigurationGcp.java @@ -0,0 +1,62 @@ +package com.spotinst.sdkjava.model.api.gcp; + +import com.fasterxml.jackson.annotation.JsonFilter; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.spotinst.sdkjava.client.rest.IPartialUpdateEntity; + +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +@JsonFilter("PartialUpdateEntityFilter") +public class ApiElastigroupScalingConfigurationGcp implements IPartialUpdateEntity { + + @JsonIgnore + private Set isSet; + private List up; + private List down; + + public ApiElastigroupScalingConfigurationGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public List getUp() { + return up; + } + + public void setUp(List up) { + isSet.add("up"); + this.up = up; + } + + public List getDown() { + return down; + } + + public void setDown(List down) { + isSet.add("down"); + this.down = down; + } + + @JsonIgnore + public boolean isUpSet() { + return isSet.contains("up"); + } + + @JsonIgnore + public boolean isDownSet() { + return isSet.contains("down"); + } +} diff --git a/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupScalingDimensionGcp.java b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupScalingDimensionGcp.java new file mode 100644 index 000000000..9ffdf743f --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupScalingDimensionGcp.java @@ -0,0 +1,60 @@ +package com.spotinst.sdkjava.model.api.gcp; + +import com.fasterxml.jackson.annotation.JsonFilter; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.spotinst.sdkjava.client.rest.IPartialUpdateEntity; + +import java.util.HashSet; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +@JsonFilter("PartialUpdateEntityFilter") +public class ApiElastigroupScalingDimensionGcp implements IPartialUpdateEntity { + @JsonIgnore + private Set isSet; + private String name; + private String value; + + public ApiElastigroupScalingDimensionGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public String getName() { + return name; + } + + public void setName(String name) { + isSet.add("name"); + this.name = name; + } + + public String getValue() { + return value; + } + + public void setValue(String value) { + isSet.add("value"); + this.value = value; + } + + @JsonIgnore + public boolean isNameSet() { + return isSet.contains("name"); + } + + @JsonIgnore + public boolean isValueSet() { + return isSet.contains("value"); + } +} diff --git a/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupScalingPolicyGcp.java b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupScalingPolicyGcp.java new file mode 100644 index 000000000..4f13adf77 --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupScalingPolicyGcp.java @@ -0,0 +1,230 @@ +package com.spotinst.sdkjava.model.api.gcp; + +import com.fasterxml.jackson.annotation.JsonFilter; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.spotinst.sdkjava.client.rest.IPartialUpdateEntity; + +import java.util.HashSet; +import java.util.List; +import java.util.Set; + + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +@JsonFilter("PartialUpdateEntityFilter") +public class ApiElastigroupScalingPolicyGcp implements IPartialUpdateEntity { + @JsonIgnore + private Set isSet; + private ApiElastigroupScalingActionGcp action; + private Integer cooldown; + private String policyName; + private String metricName; + private String source; + private String statistic; + private Integer threshold; + private String unit; + private String namespace; + private Integer period; + private Integer evaluationPeriods; + private List dimensions; + private String operator; + + + public ApiElastigroupScalingPolicyGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public String getMetricName() { + return metricName; + } + + public void setMetricName(String metricName) { + isSet.add("metricName"); + this.metricName = metricName; + } + + public String getSource() { + return source; + } + + public void setSource(String source) { + isSet.add("source"); + this.source = source; + } + + public String getStatistic() { + return statistic; + } + + public void setStatistic(String statistics) { + isSet.add("statistic"); + this.statistic = statistics; + } + + public String getUnit() { + return unit; + } + + public void setUnit(String unit) { + isSet.add("unit"); + this.unit = unit; + } + + public Integer getThreshold() { + return threshold; + } + + public void setThreshold(Integer threshold) { + isSet.add("threshold"); + this.threshold = threshold; + } + + public String getNamespace() { + return namespace; + } + + public void setNamespace(String namespace) { + isSet.add("namespace"); + this.namespace = namespace; + } + + public Integer getPeriod() { + return period; + } + + public void setPeriod(Integer period) { + isSet.add("period"); + this.period = period; + } + + public Integer getEvaluationPeriods() { + return evaluationPeriods; + } + + public void setEvaluationPeriods(Integer evaluationPeriods) { + isSet.add("evaluationPeriods"); + this.evaluationPeriods = evaluationPeriods; + } + + public Integer getCooldown() { + return cooldown; + } + + public void setCooldown(Integer cooldown) { + isSet.add("cooldown"); + this.cooldown = cooldown; + } + + public String getPolicyName() { + return policyName; + } + + public void setPolicyName(String policyName) { + isSet.add("policyName"); + this.policyName = policyName; + } + + public List getDimensions() { + return dimensions; + } + + public void setDimensions(List dimensions) { + isSet.add("dimensions"); + this.dimensions = dimensions; + } + + public String getOperator() { + return operator; + } + + public void setOperator(String operator) { + isSet.add("operator"); + this.operator = operator; + } + + public ApiElastigroupScalingActionGcp getAction() { + return action; + } + + public void setAction(ApiElastigroupScalingActionGcp action) { + isSet.add("action"); + this.action = action; + } + + + @JsonIgnore + public boolean isPolicyNameSet() { + return isSet.contains("policyName"); + } + + @JsonIgnore + public boolean isMetricNameSet() { + return isSet.contains("metricName"); + } + + @JsonIgnore + public boolean isSourceSet() { + return isSet.contains("source"); + } + + @JsonIgnore + public boolean isStatisticSet() { + return isSet.contains("statistic"); + } + + @JsonIgnore + public boolean isUnitSet() { + return isSet.contains("unit"); + } + + @JsonIgnore + public boolean isThresholdSet() { + return isSet.contains("threshold"); + } + + @JsonIgnore + public boolean isNamespaceSet() { + return isSet.contains("namespace"); + } + + @JsonIgnore + public boolean isPeriodSet() { + return isSet.contains("period"); + } + + @JsonIgnore + public boolean isEvaluationPeriodsSet() { + return isSet.contains("evaluationPeriods"); + } + + @JsonIgnore + public boolean isCooldownSet() { + return isSet.contains("cooldown"); + } + + @JsonIgnore + public boolean isDimensionsSet() { + return isSet.contains("dimensions"); + } + + @JsonIgnore + public boolean isActionSet() { + return isSet.contains("action"); + } + + @JsonIgnore + public boolean isOperatorSet() { + return isSet.contains("operator"); + } + +} diff --git a/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupScheduleTasksConfigurationGcp.java b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupScheduleTasksConfigurationGcp.java new file mode 100644 index 000000000..32969e96d --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupScheduleTasksConfigurationGcp.java @@ -0,0 +1,122 @@ +package com.spotinst.sdkjava.model.api.gcp; + + +import com.fasterxml.jackson.annotation.JsonFilter; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.spotinst.sdkjava.client.rest.IPartialUpdateEntity; +import java.util.HashSet; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +@JsonFilter("PartialUpdateEntityFilter") +public class ApiElastigroupScheduleTasksConfigurationGcp implements IPartialUpdateEntity { + + @JsonIgnore + private Set isSet; + private String cronExpression; + private Boolean isEnabled; + private Integer maxCapacity; + private Integer minCapacity; + private Integer targetCapacity; + private String taskType; + + public ApiElastigroupScheduleTasksConfigurationGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public String getCronExpression() { + return cronExpression; + } + + public void setCronExpression(String cronExpression) { + isSet.add("cronExpression"); + this.cronExpression = cronExpression; + } + + public Boolean getIsEnabled() { + return isEnabled; + } + + public void setIsEnabled(Boolean isEnabled) { + isSet.add("isEnabled"); + this.isEnabled = isEnabled; + } + + public String getTaskType() { + return taskType; + } + + public void setTaskType(String taskType) { + isSet.add("taskType"); + + this.taskType = taskType; + } + + public Integer getTargetCapacity() { + return targetCapacity; + } + + public void setTargetCapacity(Integer targetCapacity) { + isSet.add("targetCapacity"); + this.targetCapacity = targetCapacity; + } + + public Integer getMinCapacity() { + return minCapacity; + } + + public void setMinCapacity(Integer minCapacity) { + isSet.add("minCapacity"); + this.minCapacity = minCapacity; + } + + public Integer getMaxCapacity() { + return maxCapacity; + } + + public void setMaxCapacity(Integer maxCapacity) { + isSet.add("maxCapacity"); + this.maxCapacity = maxCapacity; + } + + @JsonIgnore + public boolean isIsEnabledSet() { + return isSet.contains("isEnabled"); + } + + @JsonIgnore + public boolean isCronExpressionSet() { + return isSet.contains("cronExpression"); + } + + @JsonIgnore + public boolean isTaskTypeSet() { + return isSet.contains("taskType"); + } + + @JsonIgnore + public boolean isTargetCapacitySet() { + return isSet.contains("targetCapacity"); + } + + @JsonIgnore + public boolean isMinCapacitySet() { + return isSet.contains("minCapacity"); + } + + @JsonIgnore + public boolean isMaxCapacitySet() { + return isSet.contains("maxCapacity"); + } +} diff --git a/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupSchedulingGcp.java b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupSchedulingGcp.java new file mode 100644 index 000000000..6fa8d1876 --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupSchedulingGcp.java @@ -0,0 +1,47 @@ +package com.spotinst.sdkjava.model.api.gcp; + +import com.fasterxml.jackson.annotation.JsonFilter; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.spotinst.sdkjava.client.rest.IPartialUpdateEntity; + +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +@JsonFilter("PartialUpdateEntityFilter") +public class ApiElastigroupSchedulingGcp implements IPartialUpdateEntity { + + @JsonIgnore + private Set isSet; + private List tasks; + + public ApiElastigroupSchedulingGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public List getTasks() { + return tasks; + } + + public void setTasks(List tasks) { + isSet.add("tasks"); + this.tasks = tasks; + } + + @JsonIgnore + public boolean isTasksSet() { + return isSet.contains("tasks"); + } +} diff --git a/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupThirdPartiesIntegrationGcp.java b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupThirdPartiesIntegrationGcp.java new file mode 100644 index 000000000..a3b4f4093 --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiElastigroupThirdPartiesIntegrationGcp.java @@ -0,0 +1,61 @@ +package com.spotinst.sdkjava.model.api.gcp; + +import com.fasterxml.jackson.annotation.JsonFilter; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.spotinst.sdkjava.client.rest.IPartialUpdateEntity; + +import java.util.HashSet; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +@JsonFilter("PartialUpdateEntityFilter") +public class ApiElastigroupThirdPartiesIntegrationGcp implements IPartialUpdateEntity { + + @JsonIgnore + private Set isSet; + private ApiElastigroupDockerSwarmGcp dockerSwarm; + private ApiElastigroupGkeConfigurationGcp gke; + + public ApiElastigroupThirdPartiesIntegrationGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public ApiElastigroupDockerSwarmGcp getDockerSwarm() { + return dockerSwarm; + } + + public void setDockerSwarm(ApiElastigroupDockerSwarmGcp dockerSwarm) { + isSet.add("dockerSwarm"); + this.dockerSwarm = dockerSwarm; + } + + public ApiElastigroupGkeConfigurationGcp getGke() { + return gke; + } + + public void setGke(ApiElastigroupGkeConfigurationGcp gke) { + isSet.add("gke"); + this.gke = gke; + } + + @JsonIgnore + public boolean isDockerSwarmSet() { + return isSet.contains("dockerSwarm"); + } + + @JsonIgnore + public boolean isGkeSet() { + return isSet.contains("gke"); + } +} diff --git a/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiGroupComputeGcp.java b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiGroupComputeGcp.java index 4c06a73d6..2d0ca1be4 100755 --- a/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiGroupComputeGcp.java +++ b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiGroupComputeGcp.java @@ -22,6 +22,9 @@ public class ApiGroupComputeGcp implements IPartialUpdateEntity { private List subnets; private ApiLaunchSpecificationGcp launchSpecification; private ApiInstanceTypesGcp instanceTypes; + private ApiElastigroupHealthGcp health; + private List preferredAvailabilityZones; + private ApiElastigroupGpuGcp gpu; //endregion //region Constructor @@ -74,6 +77,33 @@ public void setLaunchSpecification(ApiLaunchSpecificationGcp launchSpecification isSet.add("launchSpecification"); this.launchSpecification = launchSpecification; } + + public ApiElastigroupHealthGcp getHealth() { + return health; + } + + public void setHealth(ApiElastigroupHealthGcp health) { + isSet.add("health"); + this.health = health; + } + + public ApiElastigroupGpuGcp getGpu() { + return gpu; + } + + public void setGpu(ApiElastigroupGpuGcp gpu) { + isSet.add("gpu"); + this.gpu = gpu; + } + + public List getPreferredAvailabilityZones() { + return preferredAvailabilityZones; + } + + public void setPreferredAvailabilityZones(List preferredAvailabilityZones) { + isSet.add("preferredAvailabilityZones"); + this.preferredAvailabilityZones = preferredAvailabilityZones; + } //end region //region is set methods @@ -100,5 +130,14 @@ public boolean isInstanceTypesSet() { public boolean isLaunchSpecificationSet() { return isSet.contains("launchSpecification"); } + + @JsonIgnore + public boolean isHealthSet() { return isSet.contains("health"); } + + @JsonIgnore + public boolean isGpuSet() { return isSet.contains("gpu"); } + + @JsonIgnore + public boolean isPreferredAvailabilityZonesSet() { return isSet.contains("preferredAvailabilityZones"); } //endregion } diff --git a/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiInstanceTypesGcp.java b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiInstanceTypesGcp.java index 86824b384..8022854df 100755 --- a/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiInstanceTypesGcp.java +++ b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiInstanceTypesGcp.java @@ -16,9 +16,11 @@ public class ApiInstanceTypesGcp implements IPartialUpdateEntity { //region members @JsonIgnore - private Set isSet; - private List preemptible; - private String ondemand; + private Set isSet; + private List preemptible; + private String ondemand; + private ApiElastigroupCustomInstanceTypesGcp custom; + private ApiElastigroupPreferredInstanceTypesGcp preferred; //endregion //region Constructor @@ -53,6 +55,24 @@ public void setOndemand(String ondemand) { isSet.add("ondemand"); this.ondemand = ondemand; } + + public ApiElastigroupCustomInstanceTypesGcp getCustom() { + return custom; + } + + public void setCustom(ApiElastigroupCustomInstanceTypesGcp custom) { + isSet.add("custom"); + this.custom = custom; + } + + public ApiElastigroupPreferredInstanceTypesGcp getPreferred() { + return preferred; + } + + public void setPreferred(ApiElastigroupPreferredInstanceTypesGcp preferred) { + isSet.add("preferred"); + this.preferred = preferred; + } //endregion //region isSet methods @@ -67,5 +87,11 @@ public boolean isPreemptibleSet() { public boolean isOndemandSet() { return isSet.contains("ondemand"); } + + @JsonIgnore + public boolean isCustomSet() { return isSet.contains("custom"); } + + @JsonIgnore + public boolean isPreferredSet() { return isSet.contains("preferred"); } //endregion } diff --git a/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiLaunchSpecificationGcp.java b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiLaunchSpecificationGcp.java index 6ac097e21..10218dff1 100755 --- a/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiLaunchSpecificationGcp.java +++ b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiLaunchSpecificationGcp.java @@ -16,9 +16,17 @@ public class ApiLaunchSpecificationGcp implements IPartialUpdateEntity { //region Members @JsonIgnore - private Set isSet; - private List disks; - private List networkInterfaces; + private Set isSet; + private List disks; + private List networkInterfaces; + private ApiElastigroupBackendServiceConfigGcp backendServiceConfig; + private String instanceNamePrefix; + private Boolean ipForwarding; + private List metadata; + private String minCpuPlatform; + private String shutdownScript; + private String startupScript; + private List tags; //endregion //region Constructor @@ -53,6 +61,62 @@ public void setNetworkInterfaces(List networkInterfaces isSet.add("networkInterfaces"); this.networkInterfaces = networkInterfaces; } + + public ApiElastigroupBackendServiceConfigGcp getBackendServiceConfig() { return backendServiceConfig; } + + public void setBackendServiceConfig(ApiElastigroupBackendServiceConfigGcp backendServiceConfig) { + isSet.add("backendServiceConfig"); + this.backendServiceConfig = backendServiceConfig; + } + + public String getInstanceNamePrefix() { return instanceNamePrefix; } + + public void setInstanceNamePrefix(String instanceNamePrefix) { + isSet.add("instanceNamePrefix"); + this.instanceNamePrefix = instanceNamePrefix; + } + + public Boolean getIpForwarding() { return ipForwarding; } + + public void setIpForwarding(Boolean ipForwarding) { + isSet.add("ipForwarding"); + this.ipForwarding = ipForwarding; + } + + public String getMinCpuPlatform() { return minCpuPlatform; } + + public void setMinCpuPlatform(String minCpuPlatform) { + isSet.add("minCpuPlatform"); + this.minCpuPlatform = minCpuPlatform; + } + + public List getMetadata() { return metadata; } + + public void setMetadata(List metadata) { + isSet.add("metadata"); + this.metadata = metadata; + } + + public String getShutdownScript() { return shutdownScript; } + + public void setShutdownScript(String shutdownScript) { + isSet.add("shutdownScript"); + this.shutdownScript = shutdownScript; + } + + public String getStartupScript() { return startupScript; } + + public void setStartupScript(String startupScript) { + isSet.add("startupScript"); + this.startupScript = startupScript; + } + + public List getTags() { return tags; } + + public void setTags(List tags) { + isSet.add("tags"); + this.tags = tags; + } //endregion //region isSet methods @@ -67,5 +131,29 @@ public boolean isDisksSet() { public boolean isNetworkInterfacesSet() { return isSet.contains("networkInterfaces"); } + + @JsonIgnore + public boolean isBackendServiceConfigSet() { return isSet.contains("backendServiceConfig"); } + + @JsonIgnore + public boolean isInstanceNamePrefixSet() { return isSet.contains("instanceNamePrefix"); } + + @JsonIgnore + public boolean isIpForwardingSet() { return isSet.contains("ipForwarding"); } + + @JsonIgnore + public boolean isMetadataSet() { return isSet.contains("metadata"); } + + @JsonIgnore + public boolean isMinCpuPlatformSet() { return isSet.contains("minCpuPlatform"); } + + @JsonIgnore + public boolean isShutdownScriptSet() { return isSet.contains("shutdownScript"); } + + @JsonIgnore + public boolean isStartupScriptSet() { return isSet.contains("startupScript"); } + + @JsonIgnore + public boolean isTagsSet() { return isSet.contains("tags"); } //endregion } diff --git a/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiStrategyGcp.java b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiStrategyGcp.java index 511e77711..4abcc34f5 100755 --- a/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiStrategyGcp.java +++ b/src/main/java/com/spotinst/sdkjava/model/api/gcp/ApiStrategyGcp.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.spotinst.sdkjava.client.rest.IPartialUpdateEntity; +import com.spotinst.sdkjava.enums.gcp.GcpElastigroupProvisioningModelEnum; import java.util.HashSet; import java.util.List; @@ -16,13 +17,14 @@ public class ApiStrategyGcp implements IPartialUpdateEntity { //region members @JsonIgnore - private Set isSet; - private Integer preemptiblePercentage; - private Integer onDemandCount; - private Integer drainingTimeout; - private Boolean fallbackToOd; - private ApiRevertToPreemptibleGcp revertToPreemptible; - private List optimizationWindows; + private Set isSet; + private Integer preemptiblePercentage; + private Integer onDemandCount; + private Integer drainingTimeout; + private Boolean fallbackToOd; + private ApiRevertToPreemptibleGcp revertToPreemptible; + private List optimizationWindows; + private GcpElastigroupProvisioningModelEnum provisioningModel; //endregion //region Constructor @@ -94,6 +96,15 @@ public void setDrainingTimeout(Integer drainingTimeout) { isSet.add("drainingTimeout"); this.drainingTimeout = drainingTimeout; } + + public GcpElastigroupProvisioningModelEnum getProvisioningModel() { + return provisioningModel; + } + + public void setProvisioningModel(GcpElastigroupProvisioningModelEnum provisioningModel) { + isSet.add("provisioningModel"); + this.provisioningModel = provisioningModel; + } //endregion //region isSet methods @@ -132,5 +143,10 @@ public boolean isRevertToPreemptibleSet() { public boolean isDrainingTimeoutSet() { return isSet.contains("drainingTimeout"); } + + @JsonIgnore + public boolean isProvisioningModelSet() { + return isSet.contains("provisioningModel"); + } //endregion } diff --git a/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupAutoscaleConfigurationGcp.java b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupAutoscaleConfigurationGcp.java new file mode 100644 index 000000000..18cb90fc4 --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupAutoscaleConfigurationGcp.java @@ -0,0 +1,140 @@ +package com.spotinst.sdkjava.model.bl.elastigroup.gcp; + +import com.fasterxml.jackson.annotation.JsonIgnore; + +import java.util.HashSet; +import java.util.Set; + +public class ElastigroupAutoscaleConfigurationGcp { + + @JsonIgnore + private Set isSet; + private Integer cooldown; + private ElastigroupDownSpecificationGcp down; + private ElastigroupHeadroomSpecificationGcp headroom; + private Boolean isAutoConfig; + private Boolean isEnabled; + + private ElastigroupAutoscaleConfigurationGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public Integer getCooldown() { + return cooldown; + } + + public ElastigroupDownSpecificationGcp getDown() { + return down; + } + + public void setDown(ElastigroupDownSpecificationGcp down) { + isSet.add("down"); + this.down = down; + } + + public ElastigroupHeadroomSpecificationGcp getHeadroom() { + return headroom; + } + + public void setHeadroom(ElastigroupHeadroomSpecificationGcp headroom) { + isSet.add("headroom"); + this.headroom = headroom; + } + + public void setCooldown(Integer cooldown) { + isSet.add("cooldown"); + this.cooldown = cooldown; + } + + public Boolean getIsAutoConfig() { + return isAutoConfig; + } + + public void setIsAutoConfig(Boolean isAutoConfig) { + isSet.add("isAutoConfig"); + this.isAutoConfig = isAutoConfig; + } + + public Boolean getIsEnabled() { + return isEnabled; + } + + public void setIsEnabled(Boolean isEnabled) { + isSet.add("isEnabled"); + this.isEnabled = isEnabled; + } + + public static class Builder { + private ElastigroupAutoscaleConfigurationGcp AutoScale; + + private Builder() { + this.AutoScale = new ElastigroupAutoscaleConfigurationGcp(); + } + + public static ElastigroupAutoscaleConfigurationGcp.Builder get() { + return new Builder(); + } + + public Builder setIsEnabled(final Boolean isEnabled) { + AutoScale.setIsEnabled(isEnabled); + return this; + } + + public Builder setCooldown(final Integer cooldown) { + AutoScale.setCooldown(cooldown); + return this; + } + + public Builder setDown(final ElastigroupDownSpecificationGcp Down) { + AutoScale.setDown(Down); + return this; + } + + public Builder setHeadroom(final ElastigroupHeadroomSpecificationGcp headroom) { + AutoScale.setHeadroom(headroom); + return this; + } + + public Builder setIsAutoConfig(final Boolean isAutoConfig) { + AutoScale.setIsAutoConfig(isAutoConfig); + return this; + } + + public ElastigroupAutoscaleConfigurationGcp build() { + return AutoScale; + } + } + + @JsonIgnore + public boolean isIsEnabledSet() { + return isSet.contains("isEnabled"); + } + + @JsonIgnore + public boolean isCooldownSet() { + return isSet.contains("cooldown"); + } + + @JsonIgnore + public boolean isDownSet() { + return isSet.contains("down"); + } + + @JsonIgnore + public boolean isHeadroomSet() { + return isSet.contains("headroom"); + } + + @JsonIgnore + public boolean isIsAutoConfigSet() { + return isSet.contains("isAutoConfig"); + } +} diff --git a/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupBackendServiceConfigGcp.java b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupBackendServiceConfigGcp.java new file mode 100644 index 000000000..e6c314239 --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupBackendServiceConfigGcp.java @@ -0,0 +1,64 @@ +package com.spotinst.sdkjava.model.bl.elastigroup.gcp; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; + +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +public class ElastigroupBackendServiceConfigGcp { + + @JsonIgnore + private Set isSet; + private List backendServices; + + private ElastigroupBackendServiceConfigGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public List getBackendServices() { + return backendServices; + } + + public void setBackendServices(List backendServices) { + isSet.add("backendServices"); + this.backendServices = backendServices; + } + + public static class Builder { + private ElastigroupBackendServiceConfigGcp backendServiceConfig; + + private Builder() { + this.backendServiceConfig = new ElastigroupBackendServiceConfigGcp(); + } + + public static Builder get() { + return new Builder(); + } + + public Builder setBackendServices(final List backendServices) { + backendServiceConfig.setBackendServices(backendServices); + return this; + } + + public ElastigroupBackendServiceConfigGcp build() { + return backendServiceConfig; + } + } + + @JsonIgnore + public boolean isBackendServicesSet() { return isSet.contains("backendServices"); } + +} diff --git a/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupBackendServicesGcp.java b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupBackendServicesGcp.java new file mode 100644 index 000000000..92b412ff0 --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupBackendServicesGcp.java @@ -0,0 +1,116 @@ +package com.spotinst.sdkjava.model.bl.elastigroup.gcp; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; + +import java.util.HashSet; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +public class ElastigroupBackendServicesGcp { + + @JsonIgnore + private Set isSet; + private String backendServiceName; + private String locationType; + private ElastigroupNamedPortsGcp namedPorts; + private String scheme; + + private ElastigroupBackendServicesGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public String getBackendServiceName() { + return backendServiceName; + } + + public void setBackendServiceName(String backendServiceName) { + isSet.add("backendServiceName"); + this.backendServiceName = backendServiceName; + } + + public String getLocationType() { + return locationType; + } + + public void setLocationType(String locationType) { + isSet.add("locationType"); + this.locationType = locationType; + } + + public ElastigroupNamedPortsGcp getNamedPorts() { + return namedPorts; + } + + public void setNamedPorts(ElastigroupNamedPortsGcp namedPorts) { + isSet.add("namedPorts"); + this.namedPorts = namedPorts; + } + + public String getScheme() { + return scheme; + } + + public void setScheme(String scheme) { + isSet.add("scheme"); + this.scheme = scheme; + } + + public static class Builder { + private ElastigroupBackendServicesGcp backendServices; + + private Builder() { + this.backendServices = new ElastigroupBackendServicesGcp(); + } + + public static Builder get() { + return new Builder(); + } + + public Builder setBackendServiceName(final String backendServiceName) { + backendServices.setBackendServiceName(backendServiceName); + return this; + } + + public Builder setLocationType(final String locationType) { + backendServices.setLocationType(locationType); + return this; + } + + public Builder setNamedPorts(final ElastigroupNamedPortsGcp namedPorts) { + backendServices.setNamedPorts(namedPorts); + return this; + } + + public Builder setScheme(final String scheme) { + backendServices.setScheme(scheme); + return this; + } + + public ElastigroupBackendServicesGcp build() { + return backendServices; + } + } + + @JsonIgnore + public boolean isBackendServiceNameSet() { return isSet.contains("backendServiceName"); } + + @JsonIgnore + public boolean isLocationTypeSet() { return isSet.contains("locationType"); } + + @JsonIgnore + public boolean isNamedPortsSet() { return isSet.contains("namedPorts"); } + + @JsonIgnore + public boolean isSchemeSet() { return isSet.contains("scheme"); } +} diff --git a/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupComputeGcp.java b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupComputeGcp.java index d78239b11..babeb4743 100644 --- a/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupComputeGcp.java +++ b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupComputeGcp.java @@ -1,11 +1,15 @@ package com.spotinst.sdkjava.model.bl.elastigroup.gcp; import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; import java.util.HashSet; import java.util.List; import java.util.Set; +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) public class ElastigroupComputeGcp { //region Members @JsonIgnore @@ -14,6 +18,9 @@ public class ElastigroupComputeGcp { private ElastigroupLaunchSpecificationGcp launchSpecification; private List subnets; private ElastigroupInstanceTypesGcp instanceTypes; + private ElastigroupHealthGcp health; + private List preferredAvailabilityZones; + private ElastigroupGpuGcp gpu; //endregion //region Constructor @@ -66,44 +73,86 @@ public void setLaunchSpecification(ElastigroupLaunchSpecificationGcp launchSpeci isSet.add("launchSpecification"); this.launchSpecification = launchSpecification; } - //endregion - //region Builder class - public static class Builder { - private ElastigroupComputeGcp compute; + public ElastigroupHealthGcp getHealth() { + return health; + } + + public void setHealth(ElastigroupHealthGcp health) { + isSet.add("health"); + this.health = health; + } + + public ElastigroupGpuGcp getGpu() { + return gpu; + } + + public void setGpu(ElastigroupGpuGcp gpu) { + isSet.add("gpu"); + this.gpu = gpu; + } + + public List getPreferredAvailabilityZones() { + return preferredAvailabilityZones; + } - private Builder() { - this.compute = new ElastigroupComputeGcp(); - } + public void setPreferredAvailabilityZones(List preferredAvailabilityZones) { + isSet.add("preferredAvailabilityZones"); + this.preferredAvailabilityZones = preferredAvailabilityZones; + } +//endregion - public static Builder get() { - return new Builder(); - } +//region Builder class +public static class Builder { + private ElastigroupComputeGcp compute; - public Builder setAvailabilityZones(final List availabilityZones) { - compute.setAvailabilityZones(availabilityZones); - return this; - } + private Builder() { + this.compute = new ElastigroupComputeGcp(); + } - public Builder setLaunchSpecification(final ElastigroupLaunchSpecificationGcp launchSpecification) { - compute.setLaunchSpecification(launchSpecification); - return this; - } + public static Builder get() { + return new Builder(); + } - public Builder setInstanceTypes(final ElastigroupInstanceTypesGcp instanceTypes) { - compute.setInstanceTypes(instanceTypes); - return this; - } + public Builder setAvailabilityZones(final List availabilityZones) { + compute.setAvailabilityZones(availabilityZones); + return this; + } - public Builder setSubnets(final List subnets) { - compute.setSubnets(subnets); - return this; - } + public Builder setLaunchSpecification(final ElastigroupLaunchSpecificationGcp launchSpecification) { + compute.setLaunchSpecification(launchSpecification); + return this; + } - public ElastigroupComputeGcp build() { - return compute; - } + public Builder setInstanceTypes(final ElastigroupInstanceTypesGcp instanceTypes) { + compute.setInstanceTypes(instanceTypes); + return this; } + + public Builder setSubnets(final List subnets) { + compute.setSubnets(subnets); + return this; + } + + public Builder setHealth(ElastigroupHealthGcp health) { + compute.setHealth(health); + return this; + } + + public Builder setGpu(ElastigroupGpuGcp gpu) { + compute.setGpu(gpu); + return this; + } + + public Builder setPreferredAvailabilityZones(List preferredAvailabilityZones) { + compute.setPreferredAvailabilityZones(preferredAvailabilityZones); + return this; + } + + public ElastigroupComputeGcp build() { + return compute; + } +} //endregion //region isSet methods @@ -122,6 +171,15 @@ public ElastigroupComputeGcp build() { // Is launchSpecification Set boolean method @JsonIgnore public boolean isLaunchSpecificationSet() { return isSet.contains("launchSpecification"); } + + @JsonIgnore + public boolean isHealthSet() { return isSet.contains("health"); } + + @JsonIgnore + public boolean isGpuSet() { return isSet.contains("gpu"); } + + @JsonIgnore + public boolean isPreferredAvailabilityZonesSet() { return isSet.contains("preferredAvailabilityZones"); } //endregion } \ No newline at end of file diff --git a/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupCustomInstanceTypesGcp.java b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupCustomInstanceTypesGcp.java new file mode 100644 index 000000000..46704a3ca --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupCustomInstanceTypesGcp.java @@ -0,0 +1,82 @@ +package com.spotinst.sdkjava.model.bl.elastigroup.gcp; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; + +import java.util.HashSet; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +public class ElastigroupCustomInstanceTypesGcp { + + @JsonIgnore + private Set isSet; + private Integer memoryGiB; + private Integer vCPU; + + private ElastigroupCustomInstanceTypesGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public Integer getMemoryGiB() { + return memoryGiB; + } + + public void setMemoryGiB(Integer memoryGiB) { + isSet.add("memoryGiB"); + this.memoryGiB = memoryGiB; + } + + public Integer getVCPU() { + return vCPU; + } + + public void setVCPU(Integer vCPU) { + isSet.add("vCPU"); + this.vCPU = vCPU; + } + + public static class Builder { + private ElastigroupCustomInstanceTypesGcp customInstanceTypesGcp; + + private Builder() { + this.customInstanceTypesGcp = new ElastigroupCustomInstanceTypesGcp(); + } + + public static Builder get() { + return new Builder(); + } + + public Builder setMemoryGiB(final Integer memoryGiB) { + customInstanceTypesGcp.setMemoryGiB(memoryGiB); + return this; + } + + public Builder setVCPU(final Integer vCPU) { + customInstanceTypesGcp.setVCPU(vCPU); + return this; + } + + public ElastigroupCustomInstanceTypesGcp build() { + return customInstanceTypesGcp; + } + } + + @JsonIgnore + public boolean isMemoryGiBSet() { + return isSet.contains("memoryGiB"); + } + + @JsonIgnore + public boolean isVCPUSet() { return isSet.contains("vCPU"); } +} diff --git a/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupDockerSwarmGcp.java b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupDockerSwarmGcp.java new file mode 100644 index 000000000..4961a6041 --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupDockerSwarmGcp.java @@ -0,0 +1,84 @@ +package com.spotinst.sdkjava.model.bl.elastigroup.gcp; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; + +import java.util.HashSet; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +public class ElastigroupDockerSwarmGcp { + + @JsonIgnore + private Set isSet; + private String masterHost; + private Integer masterPort; + + private ElastigroupDockerSwarmGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public String getMasterHost() { + return masterHost; + } + + public void setMasterHost(String masterHost) { + isSet.add("masterHost"); + this.masterHost = masterHost; + } + + public Integer getMasterPort() { + return masterPort; + } + + public void setMasterPort(Integer masterPort) { + isSet.add("masterPort"); + this.masterPort = masterPort; + } + + public static class Builder { + private ElastigroupDockerSwarmGcp dockerSwarmGcp; + + private Builder() { + this.dockerSwarmGcp = new ElastigroupDockerSwarmGcp(); + } + + public static Builder get() { + return new Builder(); + } + + public Builder setMasterHost(final String masterHost) { + dockerSwarmGcp.setMasterHost(masterHost); + return this; + } + + public Builder setMasterPort(final Integer masterPort) { + dockerSwarmGcp.setMasterPort(masterPort); + return this; + } + + public ElastigroupDockerSwarmGcp build() { + return dockerSwarmGcp; + } + } + + @JsonIgnore + public boolean isMasterHostSet() { + return isSet.contains("masterHost"); + } + + @JsonIgnore + public boolean isMasterPortSet() { + return isSet.contains("masterPort"); + } +} diff --git a/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupDownSpecificationGcp.java b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupDownSpecificationGcp.java new file mode 100644 index 000000000..18682104f --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupDownSpecificationGcp.java @@ -0,0 +1,60 @@ +package com.spotinst.sdkjava.model.bl.elastigroup.gcp; + +import com.fasterxml.jackson.annotation.JsonIgnore; + +import java.util.HashSet; +import java.util.Set; + +public class ElastigroupDownSpecificationGcp { + + @JsonIgnore + private Set isSet; + private Integer evaluationPeriods; + + private ElastigroupDownSpecificationGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public Integer getEvaluationPeriods() { + return evaluationPeriods; + } + + public void setEvaluationPeriods(Integer evaluationPeriods) { + isSet.add("evaluationPeriods"); + this.evaluationPeriods = evaluationPeriods; + } + + public static class Builder { + private ElastigroupDownSpecificationGcp down; + + private Builder() { + this.down = new ElastigroupDownSpecificationGcp(); + } + + public static Builder get() { + return new Builder(); + } + + public Builder setEvaluationPeriods(final Integer evaluationPeriods) { + down.setEvaluationPeriods(evaluationPeriods); + return this; + } + + public ElastigroupDownSpecificationGcp build() { + return down; + } + } + + @JsonIgnore + public boolean isEvaluationPeriodsSet() { + return isSet.contains("evaluationPeriods"); + } +} diff --git a/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupGcp.java b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupGcp.java index 56e26ca0d..8dca92e96 100644 --- a/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupGcp.java +++ b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupGcp.java @@ -9,15 +9,18 @@ public class ElastigroupGcp { //region Members @JsonIgnore - private Set isSet; - private String id; - private String name; - private String description; - private ElastigroupCapacityGcp capacity; - private ElastigroupStrategyGcp strategy; - private ElastigroupComputeGcp compute; - private Date createdAt; - private Date updatedAt; + private Set isSet; + private String id; + private String name; + private String description; + private ElastigroupCapacityGcp capacity; + private ElastigroupStrategyGcp strategy; + private ElastigroupComputeGcp compute; + private Date createdAt; + private Date updatedAt; + private ElastigroupScalingConfigurationGcp scaling; + private ElastigroupSchedulingGcp scheduling; + private ElastigroupThirdPartiesIntegrationGcp thirdPartiesIntegration; //endregion //region Constructor @@ -107,6 +110,33 @@ public void setCompute(ElastigroupComputeGcp compute) { this.compute = compute; } + public ElastigroupScalingConfigurationGcp getScaling() { + return scaling; + } + + public void setScaling(ElastigroupScalingConfigurationGcp scaling) { + isSet.add("scaling"); + this.scaling = scaling; + } + + public ElastigroupSchedulingGcp getScheduling() { + return scheduling; + } + + public void setScheduling(ElastigroupSchedulingGcp scheduling) { + isSet.add("scheduling"); + this.scheduling = scheduling; + } + + public ElastigroupThirdPartiesIntegrationGcp getThirdPartiesIntegration() { + return thirdPartiesIntegration; + } + + public void setThirdPartiesIntegration(ElastigroupThirdPartiesIntegrationGcp thirdPartiesIntegration) { + isSet.add("thirdPartiesIntegration"); + this.thirdPartiesIntegration = thirdPartiesIntegration; + } + //endregion //region Builder class @@ -155,6 +185,21 @@ public Builder setCompute(final ElastigroupComputeGcp compute) { return this; } + public Builder setScaling(final ElastigroupScalingConfigurationGcp scaling) { + elastigroup.setScaling(scaling); + return this; + } + + public Builder setScheduling(final ElastigroupSchedulingGcp scheduling) { + elastigroup.setScheduling(scheduling); + return this; + } + + public Builder setThirdPartiesIntegration(final ElastigroupThirdPartiesIntegrationGcp thirdPartiesIntegration) { + elastigroup.setThirdPartiesIntegration(thirdPartiesIntegration); + return this; + } + public ElastigroupGcp build() { // Validations return elastigroup; @@ -195,5 +240,14 @@ public ElastigroupGcp build() { // Is updatedAt Set boolean method @JsonIgnore public boolean isUpdatedAtSet() { return isSet.contains("updatedAt"); } + + @JsonIgnore + public boolean isScalingSet() { return isSet.contains("scaling"); } + + @JsonIgnore + public boolean isSchedulingSet() { return isSet.contains("scheduling"); } + + @JsonIgnore + public boolean isThirdPartiesIntegrationSet() { return isSet.contains("thirdPartiesIntegration"); } //endregion } diff --git a/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupGkeConfigurationGcp.java b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupGkeConfigurationGcp.java new file mode 100644 index 000000000..b08faf40e --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupGkeConfigurationGcp.java @@ -0,0 +1,125 @@ +package com.spotinst.sdkjava.model.bl.elastigroup.gcp; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; + +import java.util.HashSet; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +public class ElastigroupGkeConfigurationGcp { + + @JsonIgnore + private Set isSet; + private ElastigroupAutoscaleConfigurationGcp autoScale; + private Boolean autoUpdate; + private String clusterIdentifier; + private String location; + + + private ElastigroupGkeConfigurationGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public ElastigroupAutoscaleConfigurationGcp getAutoScale() { + return autoScale; + } + + public void setAutoScale(ElastigroupAutoscaleConfigurationGcp autoScale) { + isSet.add("autoScale"); + this.autoScale = autoScale; + } + + public Boolean getAutoUpdate() { + return autoUpdate; + } + + public void setAutoUpdate(Boolean autoUpdate) { + isSet.add("autoUpdate"); + this.autoUpdate = autoUpdate; + } + + public String getClusterIdentifier() { + return clusterIdentifier; + } + + public void setClusterIdentifier(String clusterIdentifier) { + isSet.add("clusterIdentifier"); + this.clusterIdentifier = clusterIdentifier; + } + + public String getLocation() { + return location; + } + + public void setLocation(String location) { + isSet.add("location"); + this.location = location; + } + + public static class Builder { + private ElastigroupGkeConfigurationGcp gkeConfigurationGcp; + + private Builder() { + this.gkeConfigurationGcp = new ElastigroupGkeConfigurationGcp(); + } + + public static Builder get() { + return new Builder(); + } + + public Builder setAutoScale(final ElastigroupAutoscaleConfigurationGcp autoScale) { + gkeConfigurationGcp.setAutoScale(autoScale); + return this; + } + + public Builder setAutoUpdate(final Boolean autoUpdate) { + gkeConfigurationGcp.setAutoUpdate(autoUpdate); + return this; + } + + public Builder setClusterIdentifier(final String clusterIdentifier) { + gkeConfigurationGcp.setClusterIdentifier(clusterIdentifier); + return this; + } + + public Builder setLocation(final String location) { + gkeConfigurationGcp.setLocation(location); + return this; + } + + public ElastigroupGkeConfigurationGcp build() { + return gkeConfigurationGcp; + } + } + + @JsonIgnore + public boolean isAutoScaleSet() { + return isSet.contains("autoScale"); + } + + @JsonIgnore + public boolean isAutoUpdateSet() { + return isSet.contains("autoUpdate"); + } + + @JsonIgnore + public boolean isClusterIdentifierSet() { + return isSet.contains("clusterIdentifier"); + } + + @JsonIgnore + public boolean isLocationSet() { + return isSet.contains("location"); + } +} diff --git a/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupGpuGcp.java b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupGpuGcp.java new file mode 100644 index 000000000..a9ab85df6 --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupGpuGcp.java @@ -0,0 +1,79 @@ +package com.spotinst.sdkjava.model.bl.elastigroup.gcp; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; + +import java.util.HashSet; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +public class ElastigroupGpuGcp { + + @JsonIgnore + private Set isSet; + private Integer count; + private String type; + + private ElastigroupGpuGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public Integer getCount() { + return count; + } + + public void setCount(Integer count) { + isSet.add("count"); + this.count = count; + } + + public String getType() { + return type; + } + + public void setType(String type) { + isSet.add("type"); + this.type = type; + } + + public static class Builder { + private ElastigroupGpuGcp gpu; + + private Builder() { + this.gpu = new ElastigroupGpuGcp(); + } + + public static Builder get() { + return new Builder(); + } + + public Builder setCount(final Integer count) { + gpu.setCount(count); + return this; + } + + public Builder setType(final String type) { + gpu.setType(type); + return this; + } + public ElastigroupGpuGcp build() { + return gpu; + } + } + + @JsonIgnore + public boolean isCountSet() { return isSet.contains("count"); } + + @JsonIgnore + public boolean isTypeSet() { return isSet.contains("type"); } +} diff --git a/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupHeadroomSpecificationGcp.java b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupHeadroomSpecificationGcp.java new file mode 100644 index 000000000..36040c7be --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupHeadroomSpecificationGcp.java @@ -0,0 +1,98 @@ +package com.spotinst.sdkjava.model.bl.elastigroup.gcp; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; + +import java.util.HashSet; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +public class ElastigroupHeadroomSpecificationGcp { + + @JsonIgnore + private Set isSet; + private Integer cpuPerUnit; + private Integer memoryPerUnit; + private Integer numOfUnits; + + private ElastigroupHeadroomSpecificationGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public Integer getCpuPerUnit() { + return cpuPerUnit; + } + + public void setCpuPerUnit(Integer cpuPerUnit) { + isSet.add("cpuPerUnit"); + this.cpuPerUnit = cpuPerUnit; + } + + public Integer getMemoryPerUnit() { + return memoryPerUnit; + } + + public void setMemoryPerUnit(Integer memoryPerUnit) { + isSet.add("memoryPerUnit"); + this.memoryPerUnit = memoryPerUnit; + } + + public Integer getNumOfUnits() { + return numOfUnits; + } + + public void setNumOfUnits(Integer numOfUnits) { + isSet.add("numOfUnits"); + this.numOfUnits = numOfUnits; + } + + public static class Builder { + private ElastigroupHeadroomSpecificationGcp headroom; + + private Builder() { + this.headroom = new ElastigroupHeadroomSpecificationGcp(); + } + + public static Builder get() { + return new Builder(); + } + + public Builder setCpuPerUnit(final Integer cpuPerUnit) { + headroom.setCpuPerUnit(cpuPerUnit); + return this; + } + + public Builder setMemoryPerUnit(final Integer memoryPerUnit) { + headroom.setMemoryPerUnit(memoryPerUnit); + return this; + } + + public Builder setNumOfUnits(final Integer numOfUnits) { + headroom.setNumOfUnits(numOfUnits); + return this; + } + + public ElastigroupHeadroomSpecificationGcp build() { + return headroom; + } + } + + @JsonIgnore + public boolean isCpuPerUnitSet() {return isSet.contains("cpuPerUnit");} + + @JsonIgnore + public boolean isMemoryPerUnitSet() {return isSet.contains("memoryPerUnit");} + + @JsonIgnore + public boolean isNumOfUnitsSet() {return isSet.contains("numOfUnits");} +} diff --git a/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupHealthGcp.java b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupHealthGcp.java new file mode 100644 index 000000000..0c6d6f110 --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupHealthGcp.java @@ -0,0 +1,117 @@ +package com.spotinst.sdkjava.model.bl.elastigroup.gcp; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.spotinst.sdkjava.enums.gcp.GcpElastigroupHealthCheckTypeEnum; +import java.util.HashSet; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +public class ElastigroupHealthGcp { + + @JsonIgnore + private Set isSet; + private Boolean autoHealing; + private Integer gracePeriod; + private GcpElastigroupHealthCheckTypeEnum healthCheckType; + private Integer unhealthyDuration; + + private ElastigroupHealthGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public Boolean getAutoHealing() { + return autoHealing; + } + + public void setAutoHealing(Boolean autoHealing) { + isSet.add("autoHealing"); + this.autoHealing = autoHealing; + } + + public Integer getGracePeriod() { + return gracePeriod; + } + + public void setGracePeriod(Integer gracePeriod) { + isSet.add("gracePeriod"); + this.gracePeriod = gracePeriod; + } + + public GcpElastigroupHealthCheckTypeEnum getHealthCheckType() { + return healthCheckType; + } + + public void setHealthCheckType(GcpElastigroupHealthCheckTypeEnum healthCheckType) { + isSet.add("healthCheckType"); + this.healthCheckType = healthCheckType; + } + + public Integer getUnhealthyDuration() { + return unhealthyDuration; + } + + public void setUnhealthyDuration(Integer unhealthyDuration) { + isSet.add("unhealthyDuration"); + this.unhealthyDuration = unhealthyDuration; + } + + public static class Builder { + private ElastigroupHealthGcp health; + + private Builder() { + this.health = new ElastigroupHealthGcp(); + } + + public static Builder get() { + return new Builder(); + } + + public Builder setAutoHealing(final Boolean autoHealing) { + health.setAutoHealing(autoHealing); + return this; + } + + public Builder setGracePeriod(final Integer gracePeriod) { + health.setGracePeriod(gracePeriod); + return this; + } + + public Builder setHealthCheckType(final GcpElastigroupHealthCheckTypeEnum healthCheckType) { + health.setHealthCheckType(healthCheckType); + return this; + } + + public Builder setUnhealthyDuration(final Integer unhealthyDuration) { + health.setUnhealthyDuration(unhealthyDuration); + return this; + } + + public ElastigroupHealthGcp build() { + return health; + } + } + + @JsonIgnore + public boolean isAutoHealingSet() { return isSet.contains("autoHealing"); } + + @JsonIgnore + public boolean isGracePeriodSet() { return isSet.contains("gracePeriod"); } + + @JsonIgnore + public boolean isHealthCheckTypeSet() { return isSet.contains("healthCheckType"); } + + @JsonIgnore + public boolean isUnhealthyDurationSet() { return isSet.contains("unhealthyDuration"); } + +} diff --git a/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupInstanceTypesGcp.java b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupInstanceTypesGcp.java index 709b0a9b0..7bb4d2ddf 100644 --- a/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupInstanceTypesGcp.java +++ b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupInstanceTypesGcp.java @@ -1,17 +1,24 @@ package com.spotinst.sdkjava.model.bl.elastigroup.gcp; import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; import java.util.HashSet; import java.util.List; import java.util.Set; +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) public class ElastigroupInstanceTypesGcp { //region Members @JsonIgnore - private Set isSet; - private List preemptible; - private String ondemand; + private Set isSet; + private List preemptible; + private String ondemand; + private ElastigroupCustomInstanceTypesGcp custom; + private ElastigroupPreferredInstanceTypesGcp preferred; + //endregion //region Constructor @@ -46,6 +53,26 @@ public void setOndemand(String ondemand) { isSet.add("ondemand"); this.ondemand = ondemand; } + + public ElastigroupCustomInstanceTypesGcp getCustom() { + return custom; + } + + public void setCustom(ElastigroupCustomInstanceTypesGcp custom) { + isSet.add("custom"); + this.custom = custom; + } + + public ElastigroupPreferredInstanceTypesGcp getPreferred() { + return preferred; + } + + public void setPreferred(ElastigroupPreferredInstanceTypesGcp preferred) { + isSet.add("preferred"); + this.preferred = preferred; + } + + //endregion //region Builder class @@ -70,6 +97,16 @@ public Builder setOndemand(final String ondemand) { return this; } + public Builder setCustom(final ElastigroupCustomInstanceTypesGcp custom) { + instanceTypes.setCustom(custom); + return this; + } + + public Builder setPreferred(final ElastigroupPreferredInstanceTypesGcp preferred) { + instanceTypes.setPreferred(preferred); + return this; + } + public ElastigroupInstanceTypesGcp build() { return instanceTypes; } @@ -86,5 +123,11 @@ public boolean isPreemptibleSet() { // Is ondemand Set boolean method @JsonIgnore public boolean isOndemandSet() { return isSet.contains("ondemand"); } + + @JsonIgnore + public boolean isCustomSet() { return isSet.contains("custom"); } + + @JsonIgnore + public boolean isPreferredSet() { return isSet.contains("preferred"); } //endregion } diff --git a/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupLaunchSpecificationGcp.java b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupLaunchSpecificationGcp.java index 2e298dd7c..a846fff26 100644 --- a/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupLaunchSpecificationGcp.java +++ b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupLaunchSpecificationGcp.java @@ -1,17 +1,30 @@ package com.spotinst.sdkjava.model.bl.elastigroup.gcp; import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; import java.util.HashSet; import java.util.List; import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) public class ElastigroupLaunchSpecificationGcp { //region Members @JsonIgnore private Set isSet; private List disks; private List networkInterfaces; + private ElastigroupBackendServiceConfigGcp backendServiceConfig; + private String instanceNamePrefix; + private Boolean ipForwarding; + private List metadata; + private String minCpuPlatform; + private String shutdownScript; + private String startupScript; + private List tags; //endregion //region Constructor @@ -44,6 +57,62 @@ public void setNetworkInterfaces(List networkIn isSet.add("networkInterfaces"); this.networkInterfaces = networkInterfaces; } + + public ElastigroupBackendServiceConfigGcp getBackendServiceConfig() { return backendServiceConfig; } + + public void setBackendServiceConfig(ElastigroupBackendServiceConfigGcp backendServiceConfig) { + isSet.add("backendServiceConfig"); + this.backendServiceConfig = backendServiceConfig; + } + + public String getInstanceNamePrefix() { return instanceNamePrefix; } + + public void setInstanceNamePrefix(String instanceNamePrefix) { + isSet.add("instanceNamePrefix"); + this.instanceNamePrefix = instanceNamePrefix; + } + + public Boolean getIpForwarding() { return ipForwarding; } + + public void setIpForwarding(Boolean ipForwarding) { + isSet.add("ipForwarding"); + this.ipForwarding = ipForwarding; + } + + public String getMinCpuPlatform() { return minCpuPlatform; } + + public void setMinCpuPlatform(String minCpuPlatform) { + isSet.add("minCpuPlatform"); + this.minCpuPlatform = minCpuPlatform; + } + + public List getMetadata() { return metadata; } + + public void setMetadata(List metadata) { + isSet.add("metadata"); + this.metadata = metadata; + } + + public String getShutdownScript() { return shutdownScript; } + + public void setShutdownScript(String shutdownScript) { + isSet.add("shutdownScript"); + this.shutdownScript = shutdownScript; + } + + public String getStartupScript() { return startupScript; } + + public void setStartupScript(String startupScript) { + isSet.add("startupScript"); + this.startupScript = startupScript; + } + + public List getTags() { return tags; } + + public void setTags(List tags) { + isSet.add("tags"); + this.tags = tags; + } //endregion //region Builder class @@ -68,6 +137,46 @@ public Builder setNetworkInterfaces(final List return this; } + public Builder setBackendServiceConfig(final ElastigroupBackendServiceConfigGcp backendServiceConfig) { + launchSpecification.setBackendServiceConfig(backendServiceConfig); + return this; + } + + public Builder setInstanceNamePrefix(final String instanceNamePrefix) { + launchSpecification.setInstanceNamePrefix(instanceNamePrefix); + return this; + } + + public Builder setIpForwarding(final Boolean ipForwarding) { + launchSpecification.setIpForwarding(ipForwarding); + return this; + } + + public Builder setMetadata(final List metadata) { + launchSpecification.setMetadata(metadata); + return this; + } + + public Builder setMinCpuPlatform(final String minCpuPlatform) { + launchSpecification.setMinCpuPlatform(minCpuPlatform); + return this; + } + + public Builder setShutdownScript(final String shutdownScript) { + launchSpecification.setShutdownScript(shutdownScript); + return this; + } + + public Builder setStartupScript(final String startupScript) { + launchSpecification.setStartupScript(startupScript); + return this; + } + + public Builder setTags(final List tags) { + launchSpecification.setTags(tags); + return this; + } + public ElastigroupLaunchSpecificationGcp build() { return launchSpecification; } @@ -82,5 +191,29 @@ public ElastigroupLaunchSpecificationGcp build() { // Is networkInterfaces Set boolean method @JsonIgnore public boolean isNetworkInterfacesSet() { return isSet.contains("networkInterfaces"); } + + @JsonIgnore + public boolean isBackendServiceConfigSet() { return isSet.contains("backendServiceConfig"); } + + @JsonIgnore + public boolean isInstanceNamePrefixSet() { return isSet.contains("instanceNamePrefix"); } + + @JsonIgnore + public boolean isIpForwardingSet() { return isSet.contains("ipForwarding"); } + + @JsonIgnore + public boolean isMetadataSet() { return isSet.contains("metadata"); } + + @JsonIgnore + public boolean isMinCpuPlatformSet() { return isSet.contains("minCpuPlatform"); } + + @JsonIgnore + public boolean isShutdownScriptSet() { return isSet.contains("shutdownScript"); } + + @JsonIgnore + public boolean isStartupScriptSet() { return isSet.contains("startupScript"); } + + @JsonIgnore + public boolean isTagsSet() { return isSet.contains("tags"); } //endregion } \ No newline at end of file diff --git a/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupMetadataGcp.java b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupMetadataGcp.java new file mode 100644 index 000000000..f215c7ba8 --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupMetadataGcp.java @@ -0,0 +1,76 @@ +package com.spotinst.sdkjava.model.bl.elastigroup.gcp; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; + +import java.util.HashSet; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +public class ElastigroupMetadataGcp { + + @JsonIgnore + private Set isSet; + private String key; + private String value; + + private ElastigroupMetadataGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public String getKey() { return key; } + + public void setKey(String key) { + isSet.add("key"); + this.key = key; + } + + public String getValue() { return value; } + + public void setValue(String value) { + isSet.add("value"); + this.value = value; + } + + public static class Builder { + private ElastigroupMetadataGcp metadataGcp; + + private Builder() { + this.metadataGcp = new ElastigroupMetadataGcp(); + } + + public static Builder get() { + return new Builder(); + } + + public Builder setKey(final String key) { + metadataGcp.setKey(key); + return this; + } + + public Builder setValue(final String value) { + metadataGcp.setValue(value); + return this; + } + + public ElastigroupMetadataGcp build() { + return metadataGcp; + } + } + + @JsonIgnore + public boolean isKeySet() { return isSet.contains("key"); } + + @JsonIgnore + public boolean isValueSet() { return isSet.contains("value"); } +} diff --git a/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupNamedPortsGcp.java b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupNamedPortsGcp.java new file mode 100644 index 000000000..7f7008423 --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupNamedPortsGcp.java @@ -0,0 +1,79 @@ +package com.spotinst.sdkjava.model.bl.elastigroup.gcp; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; + +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +public class ElastigroupNamedPortsGcp { + + @JsonIgnore + private Set isSet; + private String name; + private List ports; + + private ElastigroupNamedPortsGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public List getPorts() { + return ports; + } + + public void setPorts(List ports) { + isSet.add("ports"); + this.ports = ports; + } + + public String getName() { return name; } + + public void setName(String name) { + isSet.add("name"); + this.name = name; + } + + public static class Builder { + private ElastigroupNamedPortsGcp namedPorts; + + private Builder() { + this.namedPorts = new ElastigroupNamedPortsGcp(); + } + + public static Builder get() { + return new Builder(); + } + + public Builder setName(final String name) { + namedPorts.setName(name); + return this; + } + + public Builder setPorts(final List ports) { + namedPorts.setPorts(ports); + return this; + } + + public ElastigroupNamedPortsGcp build() { + return namedPorts; + } + } + + @JsonIgnore + public boolean isNameSet() { return isSet.contains("name"); } + + @JsonIgnore + public boolean isPortsSet() { return isSet.contains("ports"); } +} diff --git a/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupPreferredInstanceTypesGcp.java b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupPreferredInstanceTypesGcp.java new file mode 100644 index 000000000..354971d90 --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupPreferredInstanceTypesGcp.java @@ -0,0 +1,85 @@ +package com.spotinst.sdkjava.model.bl.elastigroup.gcp; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; + +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +public class ElastigroupPreferredInstanceTypesGcp { + + @JsonIgnore + private Set isSet; + private List preemptible; + private ElastigroupCustomInstanceTypesGcp custom; + + private ElastigroupPreferredInstanceTypesGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public List getPreemptible() { + return preemptible; + } + + public void setPreemptible(List preemptible) { + isSet.add("preemptible"); + this.preemptible = preemptible; + } + + public ElastigroupCustomInstanceTypesGcp getCustom() { + return custom; + } + + public void setCustom(ElastigroupCustomInstanceTypesGcp custom) { + isSet.add("custom"); + this.custom = custom; + } + + public static class Builder { + private ElastigroupPreferredInstanceTypesGcp preferredInstanceTypesGcp; + + private Builder() { + this.preferredInstanceTypesGcp = new ElastigroupPreferredInstanceTypesGcp(); + } + + public static Builder get() { + return new Builder(); + } + + public Builder setPreemptible(final List preemptible) { + preferredInstanceTypesGcp.setPreemptible(preemptible); + return this; + } + + public Builder setCustom(final ElastigroupCustomInstanceTypesGcp custom) { + preferredInstanceTypesGcp.setCustom(custom); + return this; + } + + public ElastigroupPreferredInstanceTypesGcp build() { + return preferredInstanceTypesGcp; + } + } + + @JsonIgnore + public boolean isPreemptibleSet() { + return isSet.contains("preemptible"); + } + + @JsonIgnore + public boolean isCustomSet() { return isSet.contains("custom"); } + + +} diff --git a/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupScalingActionGcp.java b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupScalingActionGcp.java new file mode 100644 index 000000000..f6d0cebc2 --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupScalingActionGcp.java @@ -0,0 +1,84 @@ +package com.spotinst.sdkjava.model.bl.elastigroup.gcp; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; + +import java.util.HashSet; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +public class ElastigroupScalingActionGcp { + + @JsonIgnore + private Set isSet; + private String type; + private Integer adjustment; + + private ElastigroupScalingActionGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public String getType() { + return type; + } + + public void setType(String type) { + isSet.add("type"); + this.type = type; + } + + public Integer getAdjustment() { + return adjustment; + } + + public void setAdjustment(Integer adjustment) { + isSet.add("adjustment"); + this.adjustment = adjustment; + } + + public static class Builder { + private ElastigroupScalingActionGcp scalingAction; + + private Builder() { + this.scalingAction = new ElastigroupScalingActionGcp(); + } + + public static Builder get() { + return new Builder(); + } + + public Builder setType(final String type) { + scalingAction.setType(type); + return this; + } + + public Builder setAdjustment(final Integer adjustment) { + scalingAction.setAdjustment(adjustment); + return this; + } + + public ElastigroupScalingActionGcp build() { + return scalingAction; + } + } + + @JsonIgnore + public boolean isTypeSet() { + return isSet.contains("type"); + } + + @JsonIgnore + public boolean isAdjustmentSet() { + return isSet.contains("adjustment"); + } +} diff --git a/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupScalingConfigurationGcp.java b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupScalingConfigurationGcp.java new file mode 100644 index 000000000..b38358b59 --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupScalingConfigurationGcp.java @@ -0,0 +1,86 @@ +package com.spotinst.sdkjava.model.bl.elastigroup.gcp; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; + +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +public class ElastigroupScalingConfigurationGcp { + + @JsonIgnore + private Set isSet; + private List up; + private List down; + + private ElastigroupScalingConfigurationGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public List getUp() { + return up; + } + + public void setUp(List up) { + isSet.add("up"); + this.up = up; + } + + public List getDown() { + return down; + } + + public void setDown(List down) { + isSet.add("down"); + this.down = down; + } + + public static class Builder { + private ElastigroupScalingConfigurationGcp elastigroupScalingConfiguration; + + private Builder() { + this.elastigroupScalingConfiguration = new ElastigroupScalingConfigurationGcp(); + } + + public static Builder get(){ + return new Builder(); + } + + public Builder setDown(final List downScalingPolicies) { + elastigroupScalingConfiguration.setDown(downScalingPolicies); + return this; + } + + public Builder setUp(final List upScalingPolicies) { + elastigroupScalingConfiguration.setUp(upScalingPolicies); + return this; + } + + public ElastigroupScalingConfigurationGcp build() { + return elastigroupScalingConfiguration; + } + } + + @JsonIgnore + public boolean isUpSet() { + return isSet.contains("up"); + } + + @JsonIgnore + public boolean isDownSet() { + return isSet.contains("down"); + } + +} diff --git a/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupScalingDimensionGcp.java b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupScalingDimensionGcp.java new file mode 100644 index 000000000..aa0a0a8c4 --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupScalingDimensionGcp.java @@ -0,0 +1,84 @@ +package com.spotinst.sdkjava.model.bl.elastigroup.gcp; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; + +import java.util.HashSet; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +public class ElastigroupScalingDimensionGcp { + + @JsonIgnore + private Set isSet; + private String name; + private String value; + + private ElastigroupScalingDimensionGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public String getName() { + return name; + } + + public void setName(String name) { + isSet.add("name"); + this.name = name; + } + + public String getValue() { + return value; + } + + public void setValue(String value) { + isSet.add("value"); + this.value = value; + } + + public static class Builder { + private ElastigroupScalingDimensionGcp dimension; + + private Builder() { + this.dimension = new ElastigroupScalingDimensionGcp(); + } + + public static Builder get() { + return new Builder(); + } + + public Builder setName(final String name) { + dimension.setName(name); + return this; + } + + public Builder setValue(final String value) { + dimension.setValue(value); + return this; + } + + public ElastigroupScalingDimensionGcp build() { + return dimension; + } + } + + @JsonIgnore + public boolean isNameSet() { + return isSet.contains("name"); + } + + @JsonIgnore + public boolean isValueSet() { + return isSet.contains("value"); + } +} diff --git a/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupScalingPolicyGcp.java b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupScalingPolicyGcp.java new file mode 100644 index 000000000..018617e51 --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupScalingPolicyGcp.java @@ -0,0 +1,307 @@ +package com.spotinst.sdkjava.model.bl.elastigroup.gcp; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; + +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +public class ElastigroupScalingPolicyGcp { + @JsonIgnore + private Set isSet; + private ElastigroupScalingActionGcp action; + private Integer cooldown; + private List dimensions; + private Integer evaluationPeriods; + private String metricName; + private String namespace; + private String operator; + private Integer period; + private String policyName; + private String source; + private String statistic; + private Integer threshold; + private String unit; + + + private ElastigroupScalingPolicyGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public String getMetricName() { + return metricName; + } + + private void setMetricName(String metricName) { + isSet.add("metricName"); + this.metricName = metricName; + } + + public String getStatistic() { + return statistic; + } + + private void setStatistic(String statistics) { + isSet.add("statistic"); + this.statistic = statistics; + } + + public String getSource() { + return source; + } + + private void setSource(String source) { + isSet.add("source"); + this.source = source; + } + + public String getUnit() { + return unit; + } + + private void setUnit(String unit) { + isSet.add("unit"); + this.unit = unit; + } + + public Integer getThreshold() { + return threshold; + } + + private void setThreshold(Integer threshold) { + isSet.add("threshold"); + this.threshold = threshold; + } + + public String getNamespace() { + return namespace; + } + + private void setNamespace(String namespace) { + isSet.add("namespace"); + this.namespace = namespace; + } + + public Integer getPeriod() { + return period; + } + + public void setPeriod(Integer period) { + isSet.add("period"); + this.period = period; + } + + public Integer getEvaluationPeriods() { + return evaluationPeriods; + } + + private void setEvaluationPeriods(Integer evaluationPeriods) { + isSet.add("evaluationPeriods"); + this.evaluationPeriods = evaluationPeriods; + } + + public Integer getCooldown() { + return cooldown; + } + + private void setCooldown(Integer cooldown) { + isSet.add("cooldown"); + this.cooldown = cooldown; + } + + public String getPolicyName() { + return policyName; + } + + private void setPolicyName(String policyName) { + isSet.add("policyName"); + this.policyName = policyName; + } + + public List getDimensions() { + return dimensions; + } + + private void setDimensions(List dimensions) { + isSet.add("dimensions"); + this.dimensions = dimensions; + } + + public String getOperator() { + return operator; + } + + public void setOperator(String operator) { + isSet.add("operator"); + this.operator = operator; + } + + public ElastigroupScalingActionGcp getAction() { + return action; + } + + public void setAction(ElastigroupScalingActionGcp action) { + isSet.add("action"); + this.action = action; + } + + public static class Builder { + private ElastigroupScalingPolicyGcp scalingPolicy; + + private Builder() { + this.scalingPolicy = new ElastigroupScalingPolicyGcp(); + } + + public static Builder get() { + return new Builder(); + } + + public Builder setUnit(final String unit) { + scalingPolicy.setUnit(unit); + return this; + } + + public Builder setThreshold(final Integer threshold) { + scalingPolicy.setThreshold(threshold); + return this; + } + + public Builder setStatistic(final String statistic) { + scalingPolicy.setStatistic(statistic); + return this; + } + + public Builder setSource(final String source) { + scalingPolicy.setSource(source); + return this; + } + + public Builder setPolicyName(final String policyName) { + scalingPolicy.setPolicyName(policyName); + return this; + } + + public Builder setPeriod(final Integer period) { + scalingPolicy.setPeriod(period); + return this; + } + + public Builder setNamespace(final String namespace) { + scalingPolicy.setNamespace(namespace); + return this; + } + + public Builder setMetricName(final String metricName) { + scalingPolicy.setMetricName(metricName); + return this; + } + + public Builder setDimensions(final List dimensions) { + scalingPolicy.setDimensions(dimensions); + return this; + } + + public Builder setCooldown(final Integer cooldown) { + scalingPolicy.setCooldown(cooldown); + return this; + } + + public Builder setAction(final ElastigroupScalingActionGcp scalingAction) { + scalingPolicy.setAction(scalingAction); + return this; + } + + public Builder setOperator(final String operator) { + scalingPolicy.setOperator(operator); + return this; + } + + public Builder setEvaluationPeriods(final Integer evaluationPeriods) { + scalingPolicy.setEvaluationPeriods(evaluationPeriods); + return this; + } + + public ElastigroupScalingPolicyGcp build() { + return scalingPolicy; + } + } + + @JsonIgnore + public boolean isActionSet() { + return isSet.contains("action"); + } + + @JsonIgnore + public boolean isCooldownSet() { + return isSet.contains("cooldown"); + } + + @JsonIgnore + public boolean isDimensionsSet() { + return isSet.contains("dimensions"); + } + + @JsonIgnore + public boolean isEvaluationPeriodsSet() { + return isSet.contains("evaluationPeriods"); + } + + @JsonIgnore + public boolean isMetricNameSet() { + return isSet.contains("metricName"); + } + + @JsonIgnore + public boolean isNamespaceSet() { + return isSet.contains("namespace"); + } + + @JsonIgnore + public boolean isOperatorSet() { + return isSet.contains("operator"); + } + + @JsonIgnore + public boolean isPeriodSet() { + return isSet.contains("period"); + } + + @JsonIgnore + public boolean isPolicyNameSet() { + return isSet.contains("policyName"); + } + + @JsonIgnore + public boolean isSourceSet() { + return isSet.contains("source"); + } + + @JsonIgnore + public boolean isStatisticSet() { + return isSet.contains("statistic"); + } + + @JsonIgnore + public boolean isThresholdSet() { + return isSet.contains("threshold"); + } + + @JsonIgnore + public boolean isUnitSet() { + return isSet.contains("unit"); + } + +} + diff --git a/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupScheduleTasksConfigurationGcp.java b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupScheduleTasksConfigurationGcp.java new file mode 100644 index 000000000..809190ef1 --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupScheduleTasksConfigurationGcp.java @@ -0,0 +1,166 @@ +package com.spotinst.sdkjava.model.bl.elastigroup.gcp; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; + +import java.util.HashSet; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +public class ElastigroupScheduleTasksConfigurationGcp { + + @JsonIgnore + private Set isSet; + private String cronExpression; + private Boolean isEnabled; + private Integer maxCapacity; + private Integer minCapacity; + private Integer targetCapacity; + private String taskType; + + private ElastigroupScheduleTasksConfigurationGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public String getCronExpression() { + return cronExpression; + } + + public void setCronExpression(String cronExpression) { + isSet.add("cronExpression"); + this.cronExpression = cronExpression; + } + + public Boolean getIsEnabled() { + return isEnabled; + } + + public void setIsEnabled(Boolean isEnabled) { + isSet.add("isEnabled"); + this.isEnabled = isEnabled; + } + + public String getTaskType() { + return taskType; + } + + public void setTaskType(String taskType) { + isSet.add("taskType"); + + this.taskType = taskType; + } + + public Integer getTargetCapacity() { + return targetCapacity; + } + + public void setTargetCapacity(Integer targetCapacity) { + isSet.add("targetCapacity"); + this.targetCapacity = targetCapacity; + } + + public Integer getMinCapacity() { + return minCapacity; + } + + public void setMinCapacity(Integer minCapacity) { + isSet.add("minCapacity"); + this.minCapacity = minCapacity; + } + + public Integer getMaxCapacity() { + return maxCapacity; + } + + public void setMaxCapacity(Integer maxCapacity) { + isSet.add("maxCapacity"); + this.maxCapacity = maxCapacity; + } + + public static class Builder { + private ElastigroupScheduleTasksConfigurationGcp tasks; + + private Builder() { + this.tasks = new ElastigroupScheduleTasksConfigurationGcp(); + } + + public static Builder get() { + return new Builder(); + } + + public Builder setIsEnabled(final Boolean isEnabled) { + tasks.setIsEnabled(isEnabled); + return this; + } + + public Builder setCronExpression(final String cronExpression) { + tasks.setCronExpression(cronExpression); + return this; + } + + public Builder setTaskType(final String taskType) { + tasks.setTaskType(taskType); + return this; + } + + public Builder setTargetCapacity(final Integer targetCapacity) { + tasks.setTargetCapacity(targetCapacity); + return this; + } + + public Builder setMinCapacity(final Integer minCapacity) { + tasks.setMinCapacity(minCapacity); + return this; + } + + public Builder setMaxCapacity(final Integer maxCapacity) { + tasks.setMaxCapacity(maxCapacity); + return this; + } + + public ElastigroupScheduleTasksConfigurationGcp build() { + return tasks; + } + + } + + @JsonIgnore + public boolean isIsEnabledSet() { + return isSet.contains("isEnabled"); + } + + @JsonIgnore + public boolean isCronExpressionSet() { + return isSet.contains("cronExpression"); + } + + @JsonIgnore + public boolean isTaskTypeSet() { + return isSet.contains("taskType"); + } + + @JsonIgnore + public boolean isTargetCapacitySet() { + return isSet.contains("targetCapacity"); + } + + @JsonIgnore + public boolean isMinCapacitySet() { + return isSet.contains("minCapacity"); + } + + @JsonIgnore + public boolean isMaxCapacitySet() { + return isSet.contains("maxCapacity"); + } +} diff --git a/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupSchedulingGcp.java b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupSchedulingGcp.java new file mode 100644 index 000000000..415b4fdc6 --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupSchedulingGcp.java @@ -0,0 +1,65 @@ +package com.spotinst.sdkjava.model.bl.elastigroup.gcp; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; + +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +public class ElastigroupSchedulingGcp { + + @JsonIgnore + private Set isSet; + private List tasks; + + private ElastigroupSchedulingGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public List getTasks() { + return tasks; + } + + public void setTasks(List tasks) { + isSet.add("tasks"); + this.tasks = tasks; + } + + public static class Builder { + private ElastigroupSchedulingGcp scheduling; + + private Builder() { + this.scheduling = new ElastigroupSchedulingGcp(); + } + + public static Builder get() { + return new Builder(); + } + + public Builder setTasks(final List tasks) { + scheduling.setTasks(tasks); + return this; + } + + public ElastigroupSchedulingGcp build() { + return scheduling; + } + } + + @JsonIgnore + public boolean isTasksSet() { + return isSet.contains("tasks"); + } +} diff --git a/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupStrategyGcp.java b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupStrategyGcp.java index 21f60b850..96189e391 100644 --- a/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupStrategyGcp.java +++ b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupStrategyGcp.java @@ -1,6 +1,7 @@ package com.spotinst.sdkjava.model.bl.elastigroup.gcp; import com.fasterxml.jackson.annotation.JsonIgnore; +import com.spotinst.sdkjava.enums.gcp.GcpElastigroupProvisioningModelEnum; import java.util.HashSet; import java.util.List; @@ -9,13 +10,14 @@ public class ElastigroupStrategyGcp { //region Members @JsonIgnore - private Set isSet; - private Integer preemptiblePercentage; - private Integer onDemandCount; - private Integer drainingTimeout; - private Boolean fallbackToOd; - private ElastigroupRevertToPreemptibleGcp revertToPreemptible; - private List optimizationWindows; + private Set isSet; + private Integer preemptiblePercentage; + private Integer onDemandCount; + private Integer drainingTimeout; + private Boolean fallbackToOd; + private ElastigroupRevertToPreemptibleGcp revertToPreemptible; + private List optimizationWindows; + private GcpElastigroupProvisioningModelEnum provisioningModel; //endregion //region Constructor @@ -86,6 +88,15 @@ public void setDrainingTimeout(Integer drainingTimeout) { isSet.add("drainingTimeout"); this.drainingTimeout = drainingTimeout; } + + public GcpElastigroupProvisioningModelEnum getProvisioningModel() { + return provisioningModel; + } + + public void setProvisioningModel(GcpElastigroupProvisioningModelEnum provisioningModel) { + isSet.add("provisioningModel"); + this.provisioningModel = provisioningModel; + } //endregion //region Builder class @@ -130,6 +141,11 @@ public Builder setOptimizationWindows(final List optimizationWindows) { return this; } + public Builder setProvisioningModel(final GcpElastigroupProvisioningModelEnum provisioningModel) { + strategy.setProvisioningModel(provisioningModel); + return this; + } + public ElastigroupStrategyGcp build() { return strategy; } @@ -160,5 +176,8 @@ public ElastigroupStrategyGcp build() { // Is optimizationWindows Set boolean method @JsonIgnore public boolean isOptimizationWindowsSet() { return isSet.contains("optimizationWindows"); } + + @JsonIgnore + public boolean isProvisioningModelSet() { return isSet.contains("provisioningModel"); } //endregion } diff --git a/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupThirdPartiesIntegrationGcp.java b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupThirdPartiesIntegrationGcp.java new file mode 100644 index 000000000..bb293ee89 --- /dev/null +++ b/src/main/java/com/spotinst/sdkjava/model/bl/elastigroup/gcp/ElastigroupThirdPartiesIntegrationGcp.java @@ -0,0 +1,84 @@ +package com.spotinst.sdkjava.model.bl.elastigroup.gcp; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; + +import java.util.HashSet; +import java.util.Set; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +public class ElastigroupThirdPartiesIntegrationGcp { + + @JsonIgnore + private Set isSet; + private ElastigroupDockerSwarmGcp dockerSwarm; + private ElastigroupGkeConfigurationGcp gke; + + private ElastigroupThirdPartiesIntegrationGcp() { + isSet = new HashSet<>(); + } + + public Set getIsSet() { + return isSet; + } + + public void setIsSet(Set isSet) { + this.isSet = isSet; + } + + public ElastigroupDockerSwarmGcp getDockerSwarm() { + return dockerSwarm; + } + + public void setDockerSwarm(ElastigroupDockerSwarmGcp dockerSwarm) { + isSet.add("dockerSwarm"); + this.dockerSwarm = dockerSwarm; + } + + public ElastigroupGkeConfigurationGcp getGke() { + return gke; + } + + public void setGke(ElastigroupGkeConfigurationGcp gke) { + isSet.add("gke"); + this.gke = gke; + } + + public static class Builder { + private ElastigroupThirdPartiesIntegrationGcp thirdPartiesIntegrationGcp; + + private Builder() { + this.thirdPartiesIntegrationGcp = new ElastigroupThirdPartiesIntegrationGcp(); + } + + public static Builder get() { + return new Builder(); + } + + public Builder setDockerSwarm(final ElastigroupDockerSwarmGcp dockerSwarm) { + thirdPartiesIntegrationGcp.setDockerSwarm(dockerSwarm); + return this; + } + + public Builder setGke(final ElastigroupGkeConfigurationGcp gke) { + thirdPartiesIntegrationGcp.setGke(gke); + return this; + } + + public ElastigroupThirdPartiesIntegrationGcp build() { + return thirdPartiesIntegrationGcp; + } + } + + @JsonIgnore + public boolean isDockerSwarmSet() { + return isSet.contains("dockerSwarm"); + } + + @JsonIgnore + public boolean isGkeSet() { + return isSet.contains("gke"); + } +} diff --git a/src/main/java/com/spotinst/sdkjava/model/converters/elastigroup/gcp/ElastigroupConverterGcp.java b/src/main/java/com/spotinst/sdkjava/model/converters/elastigroup/gcp/ElastigroupConverterGcp.java index 289d393f9..fa7cb2644 100644 --- a/src/main/java/com/spotinst/sdkjava/model/converters/elastigroup/gcp/ElastigroupConverterGcp.java +++ b/src/main/java/com/spotinst/sdkjava/model/converters/elastigroup/gcp/ElastigroupConverterGcp.java @@ -46,6 +46,18 @@ public static ApiElastigroupGcp toDal(ElastigroupGcp src) { retVal.setUpdatedAt(src.getUpdatedAt()); } + if (src.isSchedulingSet()) { + retVal.setScheduling(toDal(src.getScheduling())); + } + + if (src.isScalingSet()) { + retVal.setScaling(toDal(src.getScaling())); + } + + if (src.isThirdPartiesIntegrationSet()) { + retVal.setThirdPartiesIntegration(toDal(src.getThirdPartiesIntegration())); + } + } return retVal; @@ -61,8 +73,7 @@ private static ApiGroupComputeGcp toDal(ElastigroupComputeGcp compute) { if (compute.getAvailabilityZones() == null) { retVal.setAvailabilityZones(null); - } - else { + } else { retVal.setAvailabilityZones(new LinkedList<>(compute.getAvailabilityZones())); } } @@ -75,7 +86,7 @@ private static ApiGroupComputeGcp toDal(ElastigroupComputeGcp compute) { if (compute.getSubnets() != null) { List subnets = compute.getSubnets().stream().map(ElastigroupConverterGcp::toDal) - .collect(Collectors.toList()); + .collect(Collectors.toList()); retVal.setSubnets(subnets); } @@ -84,6 +95,23 @@ private static ApiGroupComputeGcp toDal(ElastigroupComputeGcp compute) { if (compute.isInstanceTypesSet()) { retVal.setInstanceTypes(toDal(compute.getInstanceTypes())); } + + if (compute.isGpuSet()) { + retVal.setGpu(toDal(compute.getGpu())); + } + + if (compute.isHealthSet()) { + retVal.setHealth(toDal(compute.getHealth())); + } + + if (compute.isPreferredAvailabilityZonesSet()) { + + if (compute.getPreferredAvailabilityZones() == null) { + retVal.setPreferredAvailabilityZones(null); + } else { + retVal.setPreferredAvailabilityZones(new LinkedList<>(compute.getPreferredAvailabilityZones())); + } + } } return retVal; @@ -99,10 +127,9 @@ private static ApiLaunchSpecificationGcp toDal(ElastigroupLaunchSpecificationGcp if (launchSpecification.getDisks() != null) { List optimizerDisks = launchSpecification.getDisks().stream().map(ElastigroupConverterGcp::toDal) - .collect(Collectors.toList()); + .collect(Collectors.toList()); retVal.setDisks(optimizerDisks); - } - else { + } else { retVal.setDisks(null); } } @@ -111,13 +138,56 @@ private static ApiLaunchSpecificationGcp toDal(ElastigroupLaunchSpecificationGcp if (launchSpecification.getNetworkInterfaces() != null) { List optimizerNetworkInterfaces = launchSpecification.getNetworkInterfaces().stream().map(ElastigroupConverterGcp::toDal) - .collect(Collectors.toList()); + .collect(Collectors.toList()); retVal.setNetworkInterfaces(optimizerNetworkInterfaces); + } else { + retVal.setNetworkInterfaces(null); } - else { + } + + if (launchSpecification.isBackendServiceConfigSet()) { + retVal.setBackendServiceConfig(toDal(launchSpecification.getBackendServiceConfig())); + } + + if (launchSpecification.isInstanceNamePrefixSet()) { + retVal.setInstanceNamePrefix(launchSpecification.getInstanceNamePrefix()); + } + + if (launchSpecification.isIpForwardingSet()) { + retVal.setIpForwarding(launchSpecification.getIpForwarding()); + } + + if (launchSpecification.isMetadataSet()) { + if (launchSpecification.getMetadata() != null) { + List metadataGcp = + launchSpecification.getMetadata().stream().map(ElastigroupConverterGcp::toDal) + .collect(Collectors.toList()); + retVal.setMetadata(metadataGcp); + } else { retVal.setNetworkInterfaces(null); } } + + if (launchSpecification.isMinCpuPlatformSet()) { + retVal.setMinCpuPlatform(launchSpecification.getMinCpuPlatform()); + } + + if (launchSpecification.isShutdownScriptSet()) { + retVal.setShutdownScript(launchSpecification.getShutdownScript()); + } + + if (launchSpecification.isStartupScriptSet()) { + retVal.setStartupScript(launchSpecification.getStartupScript()); + } + + if (launchSpecification.isTagsSet()) { + + if (launchSpecification.getTags() == null) { + retVal.setTags(null); + } else { + retVal.setTags(new LinkedList<>(launchSpecification.getTags())); + } + } } return retVal; @@ -215,10 +285,9 @@ private static ApiSubnetsGcp toDal(ElastigroupSubnetsGcp subnetsGcp) { if (subnetsGcp.getSubnetNames() != null) { - if(subnetsGcp.getSubnetNames() == null) { + if (subnetsGcp.getSubnetNames() == null) { retVal.setSubnetNames(null); - } - else { + } else { retVal.setSubnetNames(new LinkedHashSet<>(subnetsGcp.getSubnetNames())); } } @@ -253,10 +322,9 @@ private static ApiStrategyGcp toDal(ElastigroupStrategyGcp strategyConfiguration if (strategyConfigurationGcp.isOptimizationWindowsSet()) { - if(strategyConfigurationGcp.getOptimizationWindows() == null) { + if (strategyConfigurationGcp.getOptimizationWindows() == null) { retVal.setOptimizationWindows(null); - } - else { + } else { retVal.setOptimizationWindows(new LinkedList<>(strategyConfigurationGcp.getOptimizationWindows())); } } @@ -264,6 +332,10 @@ private static ApiStrategyGcp toDal(ElastigroupStrategyGcp strategyConfiguration if (strategyConfigurationGcp.isRevertToPreemptibleSet()) { retVal.setRevertToPreemptible(toDal(strategyConfigurationGcp.getRevertToPreemptible())); } + + if (strategyConfigurationGcp.isProvisioningModelSet()) { + retVal.setProvisioningModel(strategyConfigurationGcp.getProvisioningModel()); + } } return retVal; @@ -320,8 +392,7 @@ private static ApiInstanceTypesGcp toDal(ElastigroupInstanceTypesGcp instanceTyp if (instanceTypesGcp.getPreemptible() == null) { retVal.setPreemptible(null); - } - else { + } else { retVal.setPreemptible(new LinkedList<>(instanceTypesGcp.getPreemptible())); } } @@ -329,6 +400,403 @@ private static ApiInstanceTypesGcp toDal(ElastigroupInstanceTypesGcp instanceTyp return retVal; } + + private static ApiElastigroupScalingConfigurationGcp toDal(ElastigroupScalingConfigurationGcp scaling) { + ApiElastigroupScalingConfigurationGcp retVal = null; + + if (scaling != null) { + retVal = new ApiElastigroupScalingConfigurationGcp(); + + if (scaling.isUpSet()) { + List apiUpScalingPolicies = null; + + if (scaling.getUp() != null) { + List up = scaling.getUp(); + apiUpScalingPolicies = up.stream().map(ElastigroupConverterGcp::toDal).collect(Collectors.toList()); + } + + retVal.setUp(apiUpScalingPolicies); + } + + if (scaling.isDownSet()) { + List apiDownScalingPolicies = null; + + if (scaling.getDown() != null) { + List down = scaling.getDown(); + apiDownScalingPolicies = + down.stream().map(ElastigroupConverterGcp::toDal).collect(Collectors.toList()); + } + + retVal.setDown(apiDownScalingPolicies); + } + } + + return retVal; + } + + private static ApiElastigroupScalingPolicyGcp toDal(ElastigroupScalingPolicyGcp scalingPolicy) { + ApiElastigroupScalingPolicyGcp retVal = null; + + if (scalingPolicy != null) { + retVal = new ApiElastigroupScalingPolicyGcp(); + + if (scalingPolicy.isPolicyNameSet()) { + retVal.setPolicyName(scalingPolicy.getPolicyName()); + } + + if (scalingPolicy.isMetricNameSet()) { + retVal.setMetricName(scalingPolicy.getMetricName()); + } + + if (scalingPolicy.isStatisticSet()) { + retVal.setStatistic(scalingPolicy.getStatistic()); + } + + if (scalingPolicy.isUnitSet()) { + retVal.setUnit(scalingPolicy.getUnit()); + } + + if (scalingPolicy.isThresholdSet()) { + retVal.setThreshold(scalingPolicy.getThreshold()); + } + + if (scalingPolicy.isNamespaceSet()) { + retVal.setNamespace(scalingPolicy.getNamespace()); + } + + if (scalingPolicy.isPeriodSet()) { + retVal.setPeriod(scalingPolicy.getPeriod()); + } + + if (scalingPolicy.isEvaluationPeriodsSet()) { + retVal.setEvaluationPeriods(scalingPolicy.getEvaluationPeriods()); + } + + if (scalingPolicy.isCooldownSet()) { + retVal.setCooldown(scalingPolicy.getCooldown()); + } + + if (scalingPolicy.isDimensionsSet()) { + List dimensions = scalingPolicy.getDimensions(); + + if (dimensions != null) { + List optimizerScalingDimensions = + dimensions.stream().map(ElastigroupConverterGcp::toDal).collect(Collectors.toList()); + retVal.setDimensions(optimizerScalingDimensions); + } + } + + if (scalingPolicy.isActionSet()) { + retVal.setAction(toDal(scalingPolicy.getAction())); + } + + if (scalingPolicy.isOperatorSet()) { + retVal.setOperator(scalingPolicy.getOperator()); + } + } + + return retVal; + } + + private static ApiElastigroupScalingDimensionGcp toDal(ElastigroupScalingDimensionGcp scalingDimension) { + ApiElastigroupScalingDimensionGcp retVal = null; + + if (scalingDimension != null) { + retVal = new ApiElastigroupScalingDimensionGcp(); + + if (scalingDimension.isNameSet()) { + retVal.setName(scalingDimension.getName()); + } + + if (scalingDimension.isValueSet()) { + retVal.setValue(scalingDimension.getValue()); + } + } + + return retVal; + } + + + private static ApiElastigroupScalingActionGcp toDal(ElastigroupScalingActionGcp scalingAction) { + ApiElastigroupScalingActionGcp retVal = null; + + if (scalingAction != null) { + retVal = new ApiElastigroupScalingActionGcp(); + + if (scalingAction.isTypeSet()) { + retVal.setType(scalingAction.getType()); + } + + if (scalingAction.isAdjustmentSet()) { + retVal.setAdjustment(scalingAction.getAdjustment()); + } + } + + return retVal; + } + + private static ApiElastigroupSchedulingGcp toDal(ElastigroupSchedulingGcp schedulingConfiguration) { + ApiElastigroupSchedulingGcp retVal = null; + if (schedulingConfiguration != null) { + retVal = new ApiElastigroupSchedulingGcp(); + if (schedulingConfiguration.isTasksSet()) { + if (schedulingConfiguration.getTasks() != null) { + List taskList = + schedulingConfiguration.getTasks().stream().map(ElastigroupConverterGcp::toDal) + .collect(Collectors.toList()); + retVal.setTasks(taskList); + } + } + } + return retVal; + } + + private static ApiElastigroupScheduleTasksConfigurationGcp toDal(ElastigroupScheduleTasksConfigurationGcp tasksConfiguration) { + ApiElastigroupScheduleTasksConfigurationGcp retVal = null; + if (tasksConfiguration != null) { + retVal = new ApiElastigroupScheduleTasksConfigurationGcp(); + if (tasksConfiguration.isIsEnabledSet()) { + retVal.setIsEnabled(tasksConfiguration.getIsEnabled()); + } + if (tasksConfiguration.isCronExpressionSet()) { + retVal.setCronExpression(tasksConfiguration.getCronExpression()); + } + if (tasksConfiguration.isTaskTypeSet()) { + retVal.setTaskType(tasksConfiguration.getTaskType()); + } + if (tasksConfiguration.isTargetCapacitySet()) { + retVal.setTargetCapacity(tasksConfiguration.getTargetCapacity()); + } + if (tasksConfiguration.isMinCapacitySet()) { + retVal.setMinCapacity(tasksConfiguration.getMinCapacity()); + } + if (tasksConfiguration.isMaxCapacitySet()) { + retVal.setMaxCapacity(tasksConfiguration.getMaxCapacity()); + } + } + return retVal; + } + + private static ApiElastigroupThirdPartiesIntegrationGcp toDal( + ElastigroupThirdPartiesIntegrationGcp thirdPartiesIntegration) { + ApiElastigroupThirdPartiesIntegrationGcp retVal = null; + + if (thirdPartiesIntegration != null) { + retVal = new ApiElastigroupThirdPartiesIntegrationGcp(); + if (thirdPartiesIntegration.isGkeSet()) { + retVal.setGke(toDal(thirdPartiesIntegration.getGke())); + } + + if (thirdPartiesIntegration.isDockerSwarmSet()) { + retVal.setDockerSwarm(toDal(thirdPartiesIntegration.getDockerSwarm())); + } + } + + return retVal; + } + + private static ApiElastigroupDockerSwarmGcp toDal(ElastigroupDockerSwarmGcp dockerSwarm) { + ApiElastigroupDockerSwarmGcp retVal = null; + if (dockerSwarm != null) { + retVal = new ApiElastigroupDockerSwarmGcp(); + if (dockerSwarm.isMasterHostSet()) { + retVal.setMasterHost(dockerSwarm.getMasterHost()); + } + if (dockerSwarm.isMasterPortSet()) { + retVal.setMasterPort(dockerSwarm.getMasterPort()); + } + } + return retVal; + } + + private static ApiElastigroupGkeConfigurationGcp toDal(ElastigroupGkeConfigurationGcp gke) { + ApiElastigroupGkeConfigurationGcp retVal = null; + if (gke != null) { + retVal = new ApiElastigroupGkeConfigurationGcp(); + if (gke.isAutoScaleSet()) { + retVal.setAutoScale(toDal(gke.getAutoScale())); + } + if (gke.isAutoUpdateSet()) { + retVal.setAutoUpdate(gke.getAutoUpdate()); + } + if (gke.isClusterIdentifierSet()) { + retVal.setLocation(gke.getClusterIdentifier()); + } + if (gke.isLocationSet()) { + retVal.setLocation(gke.getLocation()); + } + } + return retVal; + } + + private static ApiElastigroupAutoscaleConfigurationGcp toDal(ElastigroupAutoscaleConfigurationGcp autoScale) { + ApiElastigroupAutoscaleConfigurationGcp retVal = null; + if (autoScale != null) { + retVal = new ApiElastigroupAutoscaleConfigurationGcp(); + if (autoScale.isCooldownSet()) { + retVal.setCooldown(autoScale.getCooldown()); + } + if (autoScale.isDownSet()) { + retVal.setDown(toDal(autoScale.getDown())); + } + if (autoScale.isHeadroomSet()) { + retVal.setHeadroom(toDal(autoScale.getHeadroom())); + } + if (autoScale.isIsAutoConfigSet()) { + retVal.setIsAutoConfig(autoScale.getIsAutoConfig()); + } + if (autoScale.isIsEnabledSet()) { + retVal.setIsEnabled(autoScale.getIsEnabled()); + } + } + return retVal; + } + + private static ApiElastigroupDownSpecificationGcp toDal(ElastigroupDownSpecificationGcp down) { + ApiElastigroupDownSpecificationGcp retVal = null; + + if (down != null) { + retVal = new ApiElastigroupDownSpecificationGcp(); + if (down.isEvaluationPeriodsSet()) { + retVal.setEvaluationPeriods(down.getEvaluationPeriods()); + } + } + return retVal; + + } + + private static ApiElastigroupHeadroomSpecificationGcp toDal(ElastigroupHeadroomSpecificationGcp headroom) { + ApiElastigroupHeadroomSpecificationGcp retVal = null; + if (headroom != null) { + retVal = new ApiElastigroupHeadroomSpecificationGcp(); + if (headroom.isCpuPerUnitSet()) { + retVal.setCpuPerUnit(headroom.getCpuPerUnit()); + } + if (headroom.isMemoryPerUnitSet()) { + retVal.setMemoryPerUnit(headroom.getMemoryPerUnit()); + } + if (headroom.isNumOfUnitsSet()) { + retVal.setNumOfUnits(headroom.getNumOfUnits()); + } + } + return retVal; + } + + private static ApiElastigroupGpuGcp toDal(ElastigroupGpuGcp gpu) { + ApiElastigroupGpuGcp retVal = null; + if (gpu != null) { + retVal = new ApiElastigroupGpuGcp(); + if (gpu.isCountSet()) { + retVal.setCount(gpu.getCount()); + } + if (gpu.isTypeSet()) { + retVal.setType(gpu.getType()); + } + } + return retVal; + } + + private static ApiElastigroupHealthGcp toDal(ElastigroupHealthGcp health) { + ApiElastigroupHealthGcp retVal = null; + if (health != null) { + retVal = new ApiElastigroupHealthGcp(); + if (health.isAutoHealingSet()) { + retVal.setAutoHealing(health.getAutoHealing()); + } + if (health.isGracePeriodSet()) { + retVal.setGracePeriod(health.getGracePeriod()); + } + if (health.isHealthCheckTypeSet()) { + retVal.setHealthCheckType(health.getHealthCheckType()); + } + if (health.isUnhealthyDurationSet()) { + retVal.setUnhealthyDuration(health.getUnhealthyDuration()); + } + } + return retVal; + } + + private static ApiElastigroupMetadataGcp toDal(ElastigroupMetadataGcp metadataGcp) { + ApiElastigroupMetadataGcp retVal = null; + + if (metadataGcp != null) { + retVal = new ApiElastigroupMetadataGcp(); + + if (metadataGcp.isKeySet()) { + retVal.setKey(metadataGcp.getKey()); + } + + if (metadataGcp.isValueSet()) { + retVal.setValue(metadataGcp.getValue()); + } + } + + return retVal; + } + + private static ApiElastigroupBackendServiceConfigGcp toDal(ElastigroupBackendServiceConfigGcp backendServiceConfigGcp) { + ApiElastigroupBackendServiceConfigGcp retVal = null; + + if (backendServiceConfigGcp != null) { + retVal = new ApiElastigroupBackendServiceConfigGcp(); + + if (backendServiceConfigGcp.isBackendServicesSet()) { + if (backendServiceConfigGcp.getBackendServices() != null) { + List metadataGcp = + backendServiceConfigGcp.getBackendServices().stream().map(ElastigroupConverterGcp::toDal) + .collect(Collectors.toList()); + retVal.setBackendServices(metadataGcp); + } else { + retVal.setBackendServices(null); + } + } + } + + return retVal; + } + + private static ApiElastigroupBackendServicesGcp toDal(ElastigroupBackendServicesGcp backendService) { + ApiElastigroupBackendServicesGcp retVal = null; + + if (backendService != null) { + retVal = new ApiElastigroupBackendServicesGcp(); + + if (backendService.isBackendServiceNameSet()) { + retVal.setBackendServiceName(backendService.getBackendServiceName()); + } + if (backendService.isLocationTypeSet()) { + retVal.setLocationType(backendService.getLocationType()); + } + if (backendService.isSchemeSet()) { + retVal.setScheme(backendService.getScheme()); + } + if (backendService.isNamedPortsSet()) { + retVal.setNamedPorts(toDal(backendService.getNamedPorts())); + } + } + + return retVal; + } + + private static ApiElastigroupNamedPortsGcp toDal(ElastigroupNamedPortsGcp backendService) { + ApiElastigroupNamedPortsGcp retVal = null; + + if (backendService != null) { + retVal = new ApiElastigroupNamedPortsGcp(); + + if (backendService.isNameSet()) { + retVal.setName(backendService.getName()); + } + if (backendService.isPortsSet()) { + if (backendService.getPorts() == null) { + retVal.setPorts(null); + } else { + retVal.setPorts(new LinkedList<>(backendService.getPorts())); + } + } + } + return retVal; + } //endregion //region DAL -> BL @@ -372,6 +840,18 @@ public static ElastigroupGcp toBl(ApiElastigroupGcp src) { retVal.setUpdatedAt(src.getUpdatedAt()); } + if (src.isScalingSet()) { + elastigroupBuilder.setScaling(toBl(src.getScaling())); + } + + if (src.isSchedulingSet()) { + elastigroupBuilder.setScheduling(toBl(src.getScheduling())); + } + + if (src.isThirdPartiesIntegrationSet()) { + elastigroupBuilder.setThirdPartiesIntegration(toBl(src.getThirdPartiesIntegration())); + } + } return retVal; @@ -385,11 +865,9 @@ private static ElastigroupComputeGcp toBl(ApiGroupComputeGcp compute) { if (compute.isAvailabilityZonesSet()) { - if(compute.getAvailabilityZones() == null) { + if (compute.getAvailabilityZones() == null) { blComputeBuilder.setAvailabilityZones(null); - } - - else { + } else { blComputeBuilder.setAvailabilityZones(new LinkedList<>(compute.getAvailabilityZones())); } } @@ -403,11 +881,9 @@ private static ElastigroupComputeGcp toBl(ApiGroupComputeGcp compute) { List apiOptimizerSubnets = compute.getSubnets(); List optimizerSubnets = apiOptimizerSubnets.stream().map(ElastigroupConverterGcp::toBl) - .collect(Collectors.toList()); + .collect(Collectors.toList()); blComputeBuilder.setSubnets(optimizerSubnets); - } - - else { + } else { blComputeBuilder.setSubnets(null); } } @@ -436,9 +912,7 @@ private static ElastigroupLaunchSpecificationGcp toBl(ApiLaunchSpecificationGcp List optimizerDisks = apiOptimizerDisks.stream().map(ElastigroupConverterGcp::toBl).collect(Collectors.toList()); blLaunchSpecificationBuilder.setDisks(optimizerDisks); - } - - else { + } else { blLaunchSpecificationBuilder.setDisks(null); } } @@ -450,12 +924,51 @@ private static ElastigroupLaunchSpecificationGcp toBl(ApiLaunchSpecificationGcp launchSpecification.getNetworkInterfaces(); List optimizerNetworkInterfaces = apiOptimizerNetworkInterfaces.stream().map(ElastigroupConverterGcp::toBl) - .collect(Collectors.toList()); + .collect(Collectors.toList()); blLaunchSpecificationBuilder.setNetworkInterfaces(optimizerNetworkInterfaces); + } else { + blLaunchSpecificationBuilder.setNetworkInterfaces(null); } + } - else { - blLaunchSpecificationBuilder.setNetworkInterfaces(null); + if (launchSpecification.isBackendServiceConfigSet()) { + blLaunchSpecificationBuilder.setBackendServiceConfig(toBl(launchSpecification.getBackendServiceConfig())); + } + + if (launchSpecification.isInstanceNamePrefixSet()) { + blLaunchSpecificationBuilder.setInstanceNamePrefix(launchSpecification.getInstanceNamePrefix()); + } + + if (launchSpecification.isIpForwardingSet()) { + blLaunchSpecificationBuilder.setIpForwarding(launchSpecification.getIpForwarding()); + } + + if (launchSpecification.isMinCpuPlatformSet()) { + blLaunchSpecificationBuilder.setMinCpuPlatform(launchSpecification.getMinCpuPlatform()); + } + + if (launchSpecification.isShutdownScriptSet()) { + blLaunchSpecificationBuilder.setShutdownScript(launchSpecification.getShutdownScript()); + } + + if (launchSpecification.isStartupScriptSet()) { + blLaunchSpecificationBuilder.setStartupScript(launchSpecification.getStartupScript()); + } + + if (launchSpecification.getMetadata() != null) { + List apiMetadta = + launchSpecification.getMetadata(); + List metadta = + apiMetadta.stream().map(ElastigroupConverterGcp::toBl) + .collect(Collectors.toList()); + blLaunchSpecificationBuilder.setMetadata(metadta); + } else { + blLaunchSpecificationBuilder.setMetadata(null); + } + + if (launchSpecification.isTagsSet()) { + if (launchSpecification.getTags() != null) { + blLaunchSpecificationBuilder.setTags(new LinkedList<>(launchSpecification.getTags())); } } @@ -563,8 +1076,7 @@ private static ElastigroupSubnetsGcp toBl(ApiSubnetsGcp subnetsGcp) { if (subnetsGcp.isSubnetNamesSet()) { if (subnetsGcp.getSubnetNames() != null) { blSubnetsGcpBuilder.setSubnetNames(new LinkedHashSet<>(subnetsGcp.getSubnetNames())); - } - else { + } else { blSubnetsGcpBuilder.setSubnetNames(null); } } @@ -600,11 +1112,9 @@ private static ElastigroupStrategyGcp toBl(ApiStrategyGcp strategyConfigurationG if (strategyConfigurationGcp.isOptimizationWindowsSet()) { - if (strategyConfigurationGcp.getOptimizationWindows() != null){ + if (strategyConfigurationGcp.getOptimizationWindows() != null) { blStrategyConfigurationGcpBuilder.setOptimizationWindows(new LinkedList<>(strategyConfigurationGcp.getOptimizationWindows())); - } - - else { + } else { blStrategyConfigurationGcpBuilder.setOptimizationWindows(null); } } @@ -615,6 +1125,10 @@ private static ElastigroupStrategyGcp toBl(ApiStrategyGcp strategyConfigurationG blStrategyConfigurationGcpBuilder.setRevertToPreemptible(blRevertToPreemptible); } + if (strategyConfigurationGcp.isProvisioningModelSet()) { + blStrategyConfigurationGcpBuilder.setProvisioningModel(strategyConfigurationGcp.getProvisioningModel()); + } + retVal = blStrategyConfigurationGcpBuilder.build(); } @@ -679,9 +1193,7 @@ private static ElastigroupInstanceTypesGcp toBl(ApiInstanceTypesGcp instanceType if (instanceTypesGcp.getPreemptible() != null) { blInstanceTypesGcpBuilder.setPreemptible(new LinkedList<>(instanceTypesGcp.getPreemptible())); - } - - else { + } else { blInstanceTypesGcpBuilder.setPreemptible(null); } } @@ -702,12 +1214,13 @@ public static ElastigroupScaleUpResponseGcp toBl(ApiElastigroupScaleUpResponseGc List newPreemptibles = elastigroupScaleUpResponseGcp.getNewPreemptibles().stream().map(ElastigroupConverterGcp::toBl) .collect(Collectors.toList()); - retVal.setNewPreemptibles(newPreemptibles); } + retVal.setNewPreemptibles(newPreemptibles); + } - if (elastigroupScaleUpResponseGcp.isNewInstancesSet() && elastigroupScaleUpResponseGcp.getNewInstances()!=null) { + if (elastigroupScaleUpResponseGcp.isNewInstancesSet() && elastigroupScaleUpResponseGcp.getNewInstances() != null) { List newInstances = elastigroupScaleUpResponseGcp.getNewInstances().stream().map(ElastigroupConverterGcp::toBl) - .collect(Collectors.toList()); + .collect(Collectors.toList()); retVal.setNewInstances(newInstances); } } @@ -745,7 +1258,7 @@ public static ElastigroupScaleDownResponseGcp toBl(ApiElastigroupScaleDownRespon retVal.setVictimPreemptibles(victimPreemptibles); } - if (elastigroupScaleDownResponseGcp.isVictimInstancesSet() && elastigroupScaleDownResponseGcp.getVictimInstances()!=null) { + if (elastigroupScaleDownResponseGcp.isVictimInstancesSet() && elastigroupScaleDownResponseGcp.getVictimInstances() != null) { List victimInstances = elastigroupScaleDownResponseGcp.getVictimInstances().stream().map(ElastigroupConverterGcp::toBl) .collect(Collectors.toList()); @@ -773,5 +1286,400 @@ private static ElastigroupScaleDownVictimGcp toBl( } - //endregion -} \ No newline at end of file + private static ElastigroupScalingConfigurationGcp toBl(ApiElastigroupScalingConfigurationGcp scaling) { + ElastigroupScalingConfigurationGcp retVal = null; + + if (scaling != null) { + ElastigroupScalingConfigurationGcp.Builder retValBuilder = ElastigroupScalingConfigurationGcp.Builder.get(); + + if (scaling.isUpSet()) { + if (scaling.getUp() != null) { + List apiScalingPolicies = scaling.getUp(); + List scalingPolicies = + apiScalingPolicies.stream().map(ElastigroupConverterGcp::toBl).collect(Collectors.toList()); + retValBuilder.setUp(scalingPolicies); + } + } + + if (scaling.isDownSet()) { + if (scaling.getDown() != null) { + List apiScalingPolicies = scaling.getDown(); + List scalingPolicies = + apiScalingPolicies.stream().map(ElastigroupConverterGcp::toBl).collect(Collectors.toList()); + retValBuilder.setDown(scalingPolicies); + } + } + + retVal = retValBuilder.build(); + } + + return retVal; + } + + private static ElastigroupScalingPolicyGcp toBl(ApiElastigroupScalingPolicyGcp scalingPolicy) { + ElastigroupScalingPolicyGcp retVal = null; + + if (scalingPolicy != null) { + ElastigroupScalingPolicyGcp.Builder retValBuilder = ElastigroupScalingPolicyGcp.Builder.get(); + + if (scalingPolicy.isPolicyNameSet()) { + retValBuilder.setPolicyName(scalingPolicy.getPolicyName()); + } + + if (scalingPolicy.isMetricNameSet()) { + retValBuilder.setMetricName(scalingPolicy.getMetricName()); + } + + if (scalingPolicy.isStatisticSet()) { + retValBuilder.setStatistic(scalingPolicy.getStatistic()); + } + + if (scalingPolicy.isUnitSet()) { + retValBuilder.setUnit(scalingPolicy.getUnit()); + } + + if (scalingPolicy.isThresholdSet()) { + retValBuilder.setThreshold(scalingPolicy.getThreshold()); + } + + if (scalingPolicy.isNamespaceSet()) { + retValBuilder.setNamespace(scalingPolicy.getNamespace()); + } + + if (scalingPolicy.isPeriodSet()) { + retValBuilder.setPeriod(scalingPolicy.getPeriod()); + } + + if (scalingPolicy.isEvaluationPeriodsSet()) { + retValBuilder.setEvaluationPeriods(scalingPolicy.getEvaluationPeriods()); + } + + if (scalingPolicy.isCooldownSet()) { + retValBuilder.setCooldown(scalingPolicy.getCooldown()); + } + + if (scalingPolicy.isDimensionsSet()) { + if (scalingPolicy.getDimensions() != null) { + List apiDimensions = scalingPolicy.getDimensions(); + List dimensions = + apiDimensions.stream().map(ElastigroupConverterGcp::toBl).collect(Collectors.toList()); + retValBuilder.setDimensions(dimensions); + } + } + + if (scalingPolicy.isActionSet()) { + retValBuilder.setAction(toBl(scalingPolicy.getAction())); + } + + if (scalingPolicy.isOperatorSet()) { + retValBuilder.setOperator(scalingPolicy.getOperator()); + } + + retVal = retValBuilder.build(); + + } + + return retVal; + } + + private static ElastigroupScalingDimensionGcp toBl(ApiElastigroupScalingDimensionGcp scalingDimension) { + ElastigroupScalingDimensionGcp retVal = null; + + if (scalingDimension != null) { + ElastigroupScalingDimensionGcp.Builder retValBuilder = ElastigroupScalingDimensionGcp.Builder.get(); + + if (scalingDimension.isNameSet()) { + retValBuilder.setName(scalingDimension.getName()); + } + + if (scalingDimension.isValueSet()) { + retValBuilder.setValue(scalingDimension.getValue()); + } + retVal = retValBuilder.build(); + } + + return retVal; + } + + private static ElastigroupScalingActionGcp toBl(ApiElastigroupScalingActionGcp scalingAction) { + ElastigroupScalingActionGcp retVal = null; + + if (scalingAction != null) { + ElastigroupScalingActionGcp.Builder retValBuilder = ElastigroupScalingActionGcp.Builder.get(); + + if (scalingAction.isTypeSet()) { + retValBuilder.setType(scalingAction.getType()); + } + + if (scalingAction.isAdjustmentSet()) { + retValBuilder.setAdjustment(scalingAction.getAdjustment()); + } + retVal = retValBuilder.build(); + } + + return retVal; + } + + private static ElastigroupSchedulingGcp toBl(ApiElastigroupSchedulingGcp apiScheduling) { + ElastigroupSchedulingGcp blSchedulingConfiguration = null; + + if (apiScheduling != null) { + ElastigroupSchedulingGcp.Builder blSchedulingConfigurationBuilder = + ElastigroupSchedulingGcp.Builder.get(); + if (apiScheduling.isTasksSet()) { + if (apiScheduling.getTasks() != null) { + List tasksConfigurationList = + apiScheduling.getTasks().stream().map(ElastigroupConverterGcp::toBl) + .collect(Collectors.toList()); + blSchedulingConfigurationBuilder.setTasks(tasksConfigurationList); + } + } + blSchedulingConfiguration = blSchedulingConfigurationBuilder.build(); + } + return blSchedulingConfiguration; + } + + private static ElastigroupScheduleTasksConfigurationGcp toBl(ApiElastigroupScheduleTasksConfigurationGcp apiScheduledTask) { + ElastigroupScheduleTasksConfigurationGcp bLTasks = null; + + if (apiScheduledTask != null) { + ElastigroupScheduleTasksConfigurationGcp.Builder blTasksBuilder = ElastigroupScheduleTasksConfigurationGcp.Builder.get(); + if (apiScheduledTask.isIsEnabledSet()) { + blTasksBuilder.setIsEnabled(apiScheduledTask.getIsEnabled()); + } + if (apiScheduledTask.isCronExpressionSet()) { + blTasksBuilder.setCronExpression(apiScheduledTask.getCronExpression()); + } + if (apiScheduledTask.isTaskTypeSet()) { + blTasksBuilder.setTaskType(apiScheduledTask.getTaskType()); + } + if (apiScheduledTask.isTargetCapacitySet()) { + blTasksBuilder.setTargetCapacity(apiScheduledTask.getTargetCapacity()); + } + if (apiScheduledTask.isMinCapacitySet()) { + blTasksBuilder.setMinCapacity(apiScheduledTask.getMinCapacity()); + } + if (apiScheduledTask.isMaxCapacitySet()) { + blTasksBuilder.setMaxCapacity(apiScheduledTask.getMaxCapacity()); + } + + bLTasks = blTasksBuilder.build(); + } + return bLTasks; + } + + private static ElastigroupThirdPartiesIntegrationGcp toBl( + ApiElastigroupThirdPartiesIntegrationGcp apiThirdPartiesIntegration) { + ElastigroupThirdPartiesIntegrationGcp blThirdPartiesIntegration = null; + + if (apiThirdPartiesIntegration != null) { + ElastigroupThirdPartiesIntegrationGcp.Builder blThirdPartiesIntegrationBuilder = + ElastigroupThirdPartiesIntegrationGcp.Builder.get(); + + if (apiThirdPartiesIntegration.isGkeSet()) { + blThirdPartiesIntegrationBuilder.setGke(toBl(apiThirdPartiesIntegration.getGke())); + } + + if (apiThirdPartiesIntegration.isDockerSwarmSet()) { + blThirdPartiesIntegrationBuilder.setDockerSwarm(toBl(apiThirdPartiesIntegration.getDockerSwarm())); + } + blThirdPartiesIntegration = blThirdPartiesIntegrationBuilder.build(); + } + return blThirdPartiesIntegration; + } + + private static ElastigroupDockerSwarmGcp toBl( + ApiElastigroupDockerSwarmGcp apiDockerSwarm) { + ElastigroupDockerSwarmGcp blDockerSwarm = null; + + if (apiDockerSwarm != null) { + ElastigroupDockerSwarmGcp.Builder blThirdPartiesIntegrationBuilder = + ElastigroupDockerSwarmGcp.Builder.get(); + + if (apiDockerSwarm.isMasterHostSet()) { + blThirdPartiesIntegrationBuilder.setMasterHost(apiDockerSwarm.getMasterHost()); + } + + if (apiDockerSwarm.isMasterPortSet()) { + blThirdPartiesIntegrationBuilder.setMasterPort(apiDockerSwarm.getMasterPort()); + } + blDockerSwarm = blThirdPartiesIntegrationBuilder.build(); + } + return blDockerSwarm; + } + + private static ElastigroupGkeConfigurationGcp toBl(ApiElastigroupGkeConfigurationGcp apiGke) { + ElastigroupGkeConfigurationGcp blGke = null; + + if (apiGke != null) { + ElastigroupGkeConfigurationGcp.Builder blEcsBuilder = ElastigroupGkeConfigurationGcp.Builder.get(); + + if (apiGke.isAutoUpdateSet()) { + blEcsBuilder.setAutoUpdate(apiGke.getAutoUpdate()); + } + if (apiGke.isAutoScaleSet()) { + blEcsBuilder.setAutoScale(toBl(apiGke.getAutoScale())); + } + if (apiGke.isClusterIdentifierSet()) { + blEcsBuilder.setClusterIdentifier(apiGke.getClusterIdentifier()); + } + if (apiGke.isLocationSet()) { + blEcsBuilder.setLocation(apiGke.getLocation()); + } + blGke = blEcsBuilder.build(); + } + return blGke; + } + + private static ElastigroupAutoscaleConfigurationGcp toBl(ApiElastigroupAutoscaleConfigurationGcp apiAutoScale) { + ElastigroupAutoscaleConfigurationGcp blAutoScale = null; + + if (apiAutoScale != null) { + ElastigroupAutoscaleConfigurationGcp.Builder blAutoScaleBuilder = + ElastigroupAutoscaleConfigurationGcp.Builder.get(); + + if (apiAutoScale.isIsEnabledSet()) { + blAutoScaleBuilder.setIsEnabled(apiAutoScale.getIsEnabled()); + } + if (apiAutoScale.isIsAutoConfigSet()) { + blAutoScaleBuilder.setIsAutoConfig(apiAutoScale.getIsAutoConfig()); + } + if (apiAutoScale.isHeadroomSet()) { + blAutoScaleBuilder.setHeadroom(toBl(apiAutoScale.getHeadroom())); + } + if (apiAutoScale.isDownSet()) { + blAutoScaleBuilder.setDown(toBl(apiAutoScale.getDown())); + } + if (apiAutoScale.isCooldownSet()) { + blAutoScaleBuilder.setCooldown(apiAutoScale.getCooldown()); + } + blAutoScale = blAutoScaleBuilder.build(); + } + return blAutoScale; + } + + private static ElastigroupHeadroomSpecificationGcp toBl(ApiElastigroupHeadroomSpecificationGcp apiHeadroom) { + ElastigroupHeadroomSpecificationGcp blHeadroom = null; + + if (apiHeadroom != null) { + ElastigroupHeadroomSpecificationGcp.Builder blHeadroomBuilder = ElastigroupHeadroomSpecificationGcp.Builder.get(); + + if (apiHeadroom.isCpuPerUnitSet()) { + blHeadroomBuilder.setCpuPerUnit(apiHeadroom.getCpuPerUnit()); + } + if (apiHeadroom.isMemoryPerUnitSet()) { + blHeadroomBuilder.setMemoryPerUnit(apiHeadroom.getMemoryPerUnit()); + } + if (apiHeadroom.isNumOfUnitsSet()) { + blHeadroomBuilder.setNumOfUnits(apiHeadroom.getNumOfUnits()); + } + blHeadroom = blHeadroomBuilder.build(); + } + return blHeadroom; + } + + private static ElastigroupDownSpecificationGcp toBl(ApiElastigroupDownSpecificationGcp apidown) { + ElastigroupDownSpecificationGcp blDown = null; + + if (apidown != null) { + ElastigroupDownSpecificationGcp.Builder blDownBuilder = ElastigroupDownSpecificationGcp.Builder.get(); + + if (apidown.isEvaluationPeriodsSet()) { + blDownBuilder.setEvaluationPeriods(apidown.getEvaluationPeriods()); + } + blDown = blDownBuilder.build(); + } + return blDown; + } + + private static ElastigroupMetadataGcp toBl(ApiElastigroupMetadataGcp apiMetadata) { + ElastigroupMetadataGcp blMetadata = null; + + if (apiMetadata != null) { + ElastigroupMetadataGcp.Builder blDownBuilder = ElastigroupMetadataGcp.Builder.get(); + + if (apiMetadata.isKeySet()) { + blDownBuilder.setKey(apiMetadata.getKey()); + } + if (apiMetadata.isValueSet()) { + blDownBuilder.setValue(apiMetadata.getValue()); + } + blMetadata = blDownBuilder.build(); + } + return blMetadata; + } + + private static ElastigroupBackendServiceConfigGcp toBl(ApiElastigroupBackendServiceConfigGcp apiBackendService) { + ElastigroupBackendServiceConfigGcp backendServiceConfigGcp = null; + + if (apiBackendService != null) { + ElastigroupBackendServiceConfigGcp.Builder blBackendBuilder = ElastigroupBackendServiceConfigGcp.Builder.get(); + + if (apiBackendService.isBackendServicesSet()) { + if (apiBackendService.getBackendServices() != null) { + List backendService = + apiBackendService.getBackendServices().stream().map(ElastigroupConverterGcp::toBl) + .collect(Collectors.toList()); + blBackendBuilder.setBackendServices(backendService); + } + } + backendServiceConfigGcp = blBackendBuilder.build(); + } + return backendServiceConfigGcp; + } + + private static ElastigroupBackendServicesGcp toBl(ApiElastigroupBackendServicesGcp apiBackendService) { + ElastigroupBackendServicesGcp backendServiceGcp = null; + + if (apiBackendService != null) { + ElastigroupBackendServicesGcp.Builder blBackendBuilder = ElastigroupBackendServicesGcp.Builder.get(); + + if (apiBackendService.isNamedPortsSet()) { + blBackendBuilder.setNamedPorts(toBl(apiBackendService.getNamedPorts())); + } + + if (apiBackendService.isSchemeSet()) { + blBackendBuilder.setScheme(apiBackendService.getScheme()); + } + + if (apiBackendService.isLocationTypeSet()) { + blBackendBuilder.setLocationType(apiBackendService.getLocationType()); + } + + if (apiBackendService.isBackendServiceNameSet()) { + blBackendBuilder.setBackendServiceName(apiBackendService.getBackendServiceName()); + } + + backendServiceGcp = blBackendBuilder.build(); + } + return backendServiceGcp; + } + + private static ElastigroupNamedPortsGcp toBl(ApiElastigroupNamedPortsGcp apiNamedPorts) { + ElastigroupNamedPortsGcp namedPorts = null; + + if (apiNamedPorts != null) { + ElastigroupNamedPortsGcp.Builder namedPortsBuilder = ElastigroupNamedPortsGcp.Builder.get(); + + if (apiNamedPorts.isNameSet()) { + namedPortsBuilder.setName(apiNamedPorts.getName()); + } + + if (apiNamedPorts.isPortsSet()) { + namedPortsBuilder.setPorts(apiNamedPorts.getPorts()); + } + + if (apiNamedPorts.isPortsSet()) { + + if (apiNamedPorts.getPorts() == null) { + namedPortsBuilder.setPorts(null); + } else { + namedPortsBuilder.setPorts(new LinkedList<>(apiNamedPorts.getPorts())); + } + } + + namedPorts = namedPortsBuilder.build(); + } + return namedPorts; + } +}