pub fn serialize_structure_crate_input_cancel_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CancelJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.job_id {
object.key("jobId").string(var_1.as_str());
}
if let Some(var_2) = &input.reason {
object.key("reason").string(var_2.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_compute_environment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateComputeEnvironmentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3) = &input.compute_environment_name {
object.key("computeEnvironmentName").string(var_3.as_str());
}
if let Some(var_4) = &input.compute_resources {
#[allow(unused_mut)]
let mut object_5 = object.key("computeResources").start_object();
crate::json_ser::serialize_structure_crate_model_compute_resource(&mut object_5, var_4)?;
object_5.finish();
}
if let Some(var_6) = &input.eks_configuration {
#[allow(unused_mut)]
let mut object_7 = object.key("eksConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_eks_configuration(&mut object_7, var_6)?;
object_7.finish();
}
if let Some(var_8) = &input.service_role {
object.key("serviceRole").string(var_8.as_str());
}
if let Some(var_9) = &input.state {
object.key("state").string(var_9.as_str());
}
if let Some(var_10) = &input.tags {
#[allow(unused_mut)]
let mut object_11 = object.key("tags").start_object();
for (key_12, value_13) in var_10 {
{
object_11.key(key_12.as_str()).string(value_13.as_str());
}
}
object_11.finish();
}
if let Some(var_14) = &input.r#type {
object.key("type").string(var_14.as_str());
}
if let Some(var_15) = &input.unmanagedv_cpus {
object.key("unmanagedvCpus").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_15).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_create_job_queue_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateJobQueueInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_16) = &input.compute_environment_order {
let mut array_17 = object.key("computeEnvironmentOrder").start_array();
for item_18 in var_16 {
{
#[allow(unused_mut)]
let mut object_19 = array_17.value().start_object();
crate::json_ser::serialize_structure_crate_model_compute_environment_order(
&mut object_19,
item_18,
)?;
object_19.finish();
}
}
array_17.finish();
}
if let Some(var_20) = &input.job_queue_name {
object.key("jobQueueName").string(var_20.as_str());
}
if let Some(var_21) = &input.priority {
object.key("priority").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_21).into()),
);
}
if let Some(var_22) = &input.scheduling_policy_arn {
object.key("schedulingPolicyArn").string(var_22.as_str());
}
if let Some(var_23) = &input.state {
object.key("state").string(var_23.as_str());
}
if let Some(var_24) = &input.tags {
#[allow(unused_mut)]
let mut object_25 = object.key("tags").start_object();
for (key_26, value_27) in var_24 {
{
object_25.key(key_26.as_str()).string(value_27.as_str());
}
}
object_25.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_scheduling_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateSchedulingPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_28) = &input.fairshare_policy {
#[allow(unused_mut)]
let mut object_29 = object.key("fairsharePolicy").start_object();
crate::json_ser::serialize_structure_crate_model_fairshare_policy(&mut object_29, var_28)?;
object_29.finish();
}
if let Some(var_30) = &input.name {
object.key("name").string(var_30.as_str());
}
if let Some(var_31) = &input.tags {
#[allow(unused_mut)]
let mut object_32 = object.key("tags").start_object();
for (key_33, value_34) in var_31 {
{
object_32.key(key_33.as_str()).string(value_34.as_str());
}
}
object_32.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_compute_environment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteComputeEnvironmentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_35) = &input.compute_environment {
object.key("computeEnvironment").string(var_35.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_job_queue_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteJobQueueInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_36) = &input.job_queue {
object.key("jobQueue").string(var_36.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_scheduling_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteSchedulingPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_37) = &input.arn {
object.key("arn").string(var_37.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_deregister_job_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeregisterJobDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_38) = &input.job_definition {
object.key("jobDefinition").string(var_38.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_compute_environments_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeComputeEnvironmentsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_39) = &input.compute_environments {
let mut array_40 = object.key("computeEnvironments").start_array();
for item_41 in var_39 {
{
array_40.value().string(item_41.as_str());
}
}
array_40.finish();
}
if let Some(var_42) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_42).into()),
);
}
if let Some(var_43) = &input.next_token {
object.key("nextToken").string(var_43.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_job_definitions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeJobDefinitionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_44) = &input.job_definition_name {
object.key("jobDefinitionName").string(var_44.as_str());
}
if let Some(var_45) = &input.job_definitions {
let mut array_46 = object.key("jobDefinitions").start_array();
for item_47 in var_45 {
{
array_46.value().string(item_47.as_str());
}
}
array_46.finish();
}
if let Some(var_48) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_48).into()),
);
}
if let Some(var_49) = &input.next_token {
object.key("nextToken").string(var_49.as_str());
}
if let Some(var_50) = &input.status {
object.key("status").string(var_50.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_job_queues_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeJobQueuesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_51) = &input.job_queues {
let mut array_52 = object.key("jobQueues").start_array();
for item_53 in var_51 {
{
array_52.value().string(item_53.as_str());
}
}
array_52.finish();
}
if let Some(var_54) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_54).into()),
);
}
if let Some(var_55) = &input.next_token {
object.key("nextToken").string(var_55.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_56) = &input.jobs {
let mut array_57 = object.key("jobs").start_array();
for item_58 in var_56 {
{
array_57.value().string(item_58.as_str());
}
}
array_57.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_scheduling_policies_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeSchedulingPoliciesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_59) = &input.arns {
let mut array_60 = object.key("arns").start_array();
for item_61 in var_59 {
{
array_60.value().string(item_61.as_str());
}
}
array_60.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_62) = &input.array_job_id {
object.key("arrayJobId").string(var_62.as_str());
}
if let Some(var_63) = &input.filters {
let mut array_64 = object.key("filters").start_array();
for item_65 in var_63 {
{
#[allow(unused_mut)]
let mut object_66 = array_64.value().start_object();
crate::json_ser::serialize_structure_crate_model_key_values_pair(
&mut object_66,
item_65,
)?;
object_66.finish();
}
}
array_64.finish();
}
if let Some(var_67) = &input.job_queue {
object.key("jobQueue").string(var_67.as_str());
}
if let Some(var_68) = &input.job_status {
object.key("jobStatus").string(var_68.as_str());
}
if let Some(var_69) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_69).into()),
);
}
if let Some(var_70) = &input.multi_node_job_id {
object.key("multiNodeJobId").string(var_70.as_str());
}
if let Some(var_71) = &input.next_token {
object.key("nextToken").string(var_71.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_scheduling_policies_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListSchedulingPoliciesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_72) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_72).into()),
);
}
if let Some(var_73) = &input.next_token {
object.key("nextToken").string(var_73.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_register_job_definition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RegisterJobDefinitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_74) = &input.container_properties {
#[allow(unused_mut)]
let mut object_75 = object.key("containerProperties").start_object();
crate::json_ser::serialize_structure_crate_model_container_properties(
&mut object_75,
var_74,
)?;
object_75.finish();
}
if let Some(var_76) = &input.eks_properties {
#[allow(unused_mut)]
let mut object_77 = object.key("eksProperties").start_object();
crate::json_ser::serialize_structure_crate_model_eks_properties(&mut object_77, var_76)?;
object_77.finish();
}
if let Some(var_78) = &input.job_definition_name {
object.key("jobDefinitionName").string(var_78.as_str());
}
if let Some(var_79) = &input.node_properties {
#[allow(unused_mut)]
let mut object_80 = object.key("nodeProperties").start_object();
crate::json_ser::serialize_structure_crate_model_node_properties(&mut object_80, var_79)?;
object_80.finish();
}
if let Some(var_81) = &input.parameters {
#[allow(unused_mut)]
let mut object_82 = object.key("parameters").start_object();
for (key_83, value_84) in var_81 {
{
object_82.key(key_83.as_str()).string(value_84.as_str());
}
}
object_82.finish();
}
if let Some(var_85) = &input.platform_capabilities {
let mut array_86 = object.key("platformCapabilities").start_array();
for item_87 in var_85 {
{
array_86.value().string(item_87.as_str());
}
}
array_86.finish();
}
if let Some(var_88) = &input.propagate_tags {
object.key("propagateTags").boolean(*var_88);
}
if let Some(var_89) = &input.retry_strategy {
#[allow(unused_mut)]
let mut object_90 = object.key("retryStrategy").start_object();
crate::json_ser::serialize_structure_crate_model_retry_strategy(&mut object_90, var_89)?;
object_90.finish();
}
if let Some(var_91) = &input.scheduling_priority {
object.key("schedulingPriority").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_91).into()),
);
}
if let Some(var_92) = &input.tags {
#[allow(unused_mut)]
let mut object_93 = object.key("tags").start_object();
for (key_94, value_95) in var_92 {
{
object_93.key(key_94.as_str()).string(value_95.as_str());
}
}
object_93.finish();
}
if let Some(var_96) = &input.timeout {
#[allow(unused_mut)]
let mut object_97 = object.key("timeout").start_object();
crate::json_ser::serialize_structure_crate_model_job_timeout(&mut object_97, var_96)?;
object_97.finish();
}
if let Some(var_98) = &input.r#type {
object.key("type").string(var_98.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_submit_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SubmitJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_99) = &input.array_properties {
#[allow(unused_mut)]
let mut object_100 = object.key("arrayProperties").start_object();
crate::json_ser::serialize_structure_crate_model_array_properties(&mut object_100, var_99)?;
object_100.finish();
}
if let Some(var_101) = &input.container_overrides {
#[allow(unused_mut)]
let mut object_102 = object.key("containerOverrides").start_object();
crate::json_ser::serialize_structure_crate_model_container_overrides(
&mut object_102,
var_101,
)?;
object_102.finish();
}
if let Some(var_103) = &input.depends_on {
let mut array_104 = object.key("dependsOn").start_array();
for item_105 in var_103 {
{
#[allow(unused_mut)]
let mut object_106 = array_104.value().start_object();
crate::json_ser::serialize_structure_crate_model_job_dependency(
&mut object_106,
item_105,
)?;
object_106.finish();
}
}
array_104.finish();
}
if let Some(var_107) = &input.eks_properties_override {
#[allow(unused_mut)]
let mut object_108 = object.key("eksPropertiesOverride").start_object();
crate::json_ser::serialize_structure_crate_model_eks_properties_override(
&mut object_108,
var_107,
)?;
object_108.finish();
}
if let Some(var_109) = &input.job_definition {
object.key("jobDefinition").string(var_109.as_str());
}
if let Some(var_110) = &input.job_name {
object.key("jobName").string(var_110.as_str());
}
if let Some(var_111) = &input.job_queue {
object.key("jobQueue").string(var_111.as_str());
}
if let Some(var_112) = &input.node_overrides {
#[allow(unused_mut)]
let mut object_113 = object.key("nodeOverrides").start_object();
crate::json_ser::serialize_structure_crate_model_node_overrides(&mut object_113, var_112)?;
object_113.finish();
}
if let Some(var_114) = &input.parameters {
#[allow(unused_mut)]
let mut object_115 = object.key("parameters").start_object();
for (key_116, value_117) in var_114 {
{
object_115.key(key_116.as_str()).string(value_117.as_str());
}
}
object_115.finish();
}
if let Some(var_118) = &input.propagate_tags {
object.key("propagateTags").boolean(*var_118);
}
if let Some(var_119) = &input.retry_strategy {
#[allow(unused_mut)]
let mut object_120 = object.key("retryStrategy").start_object();
crate::json_ser::serialize_structure_crate_model_retry_strategy(&mut object_120, var_119)?;
object_120.finish();
}
if let Some(var_121) = &input.scheduling_priority_override {
object.key("schedulingPriorityOverride").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_121).into()),
);
}
if let Some(var_122) = &input.share_identifier {
object.key("shareIdentifier").string(var_122.as_str());
}
if let Some(var_123) = &input.tags {
#[allow(unused_mut)]
let mut object_124 = object.key("tags").start_object();
for (key_125, value_126) in var_123 {
{
object_124.key(key_125.as_str()).string(value_126.as_str());
}
}
object_124.finish();
}
if let Some(var_127) = &input.timeout {
#[allow(unused_mut)]
let mut object_128 = object.key("timeout").start_object();
crate::json_ser::serialize_structure_crate_model_job_timeout(&mut object_128, var_127)?;
object_128.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_tag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_129) = &input.tags {
#[allow(unused_mut)]
let mut object_130 = object.key("tags").start_object();
for (key_131, value_132) in var_129 {
{
object_130.key(key_131.as_str()).string(value_132.as_str());
}
}
object_130.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_terminate_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TerminateJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_133) = &input.job_id {
object.key("jobId").string(var_133.as_str());
}
if let Some(var_134) = &input.reason {
object.key("reason").string(var_134.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_compute_environment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateComputeEnvironmentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_135) = &input.compute_environment {
object.key("computeEnvironment").string(var_135.as_str());
}
if let Some(var_136) = &input.compute_resources {
#[allow(unused_mut)]
let mut object_137 = object.key("computeResources").start_object();
crate::json_ser::serialize_structure_crate_model_compute_resource_update(
&mut object_137,
var_136,
)?;
object_137.finish();
}
if let Some(var_138) = &input.service_role {
object.key("serviceRole").string(var_138.as_str());
}
if let Some(var_139) = &input.state {
object.key("state").string(var_139.as_str());
}
if let Some(var_140) = &input.unmanagedv_cpus {
object.key("unmanagedvCpus").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_140).into()),
);
}
if let Some(var_141) = &input.update_policy {
#[allow(unused_mut)]
let mut object_142 = object.key("updatePolicy").start_object();
crate::json_ser::serialize_structure_crate_model_update_policy(&mut object_142, var_141)?;
object_142.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_job_queue_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateJobQueueInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_143) = &input.compute_environment_order {
let mut array_144 = object.key("computeEnvironmentOrder").start_array();
for item_145 in var_143 {
{
#[allow(unused_mut)]
let mut object_146 = array_144.value().start_object();
crate::json_ser::serialize_structure_crate_model_compute_environment_order(
&mut object_146,
item_145,
)?;
object_146.finish();
}
}
array_144.finish();
}
if let Some(var_147) = &input.job_queue {
object.key("jobQueue").string(var_147.as_str());
}
if let Some(var_148) = &input.priority {
object.key("priority").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_148).into()),
);
}
if let Some(var_149) = &input.scheduling_policy_arn {
object.key("schedulingPolicyArn").string(var_149.as_str());
}
if let Some(var_150) = &input.state {
object.key("state").string(var_150.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_scheduling_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSchedulingPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_151) = &input.arn {
object.key("arn").string(var_151.as_str());
}
if let Some(var_152) = &input.fairshare_policy {
#[allow(unused_mut)]
let mut object_153 = object.key("fairsharePolicy").start_object();
crate::json_ser::serialize_structure_crate_model_fairshare_policy(
&mut object_153,
var_152,
)?;
object_153.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_compute_resource(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComputeResource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_154) = &input.r#type {
object.key("type").string(var_154.as_str());
}
if let Some(var_155) = &input.allocation_strategy {
object.key("allocationStrategy").string(var_155.as_str());
}
if let Some(var_156) = &input.minv_cpus {
object.key("minvCpus").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_156).into()),
);
}
if let Some(var_157) = &input.maxv_cpus {
object.key("maxvCpus").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_157).into()),
);
}
if let Some(var_158) = &input.desiredv_cpus {
object.key("desiredvCpus").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_158).into()),
);
}
if let Some(var_159) = &input.instance_types {
let mut array_160 = object.key("instanceTypes").start_array();
for item_161 in var_159 {
{
array_160.value().string(item_161.as_str());
}
}
array_160.finish();
}
if let Some(var_162) = &input.image_id {
object.key("imageId").string(var_162.as_str());
}
if let Some(var_163) = &input.subnets {
let mut array_164 = object.key("subnets").start_array();
for item_165 in var_163 {
{
array_164.value().string(item_165.as_str());
}
}
array_164.finish();
}
if let Some(var_166) = &input.security_group_ids {
let mut array_167 = object.key("securityGroupIds").start_array();
for item_168 in var_166 {
{
array_167.value().string(item_168.as_str());
}
}
array_167.finish();
}
if let Some(var_169) = &input.ec2_key_pair {
object.key("ec2KeyPair").string(var_169.as_str());
}
if let Some(var_170) = &input.instance_role {
object.key("instanceRole").string(var_170.as_str());
}
if let Some(var_171) = &input.tags {
#[allow(unused_mut)]
let mut object_172 = object.key("tags").start_object();
for (key_173, value_174) in var_171 {
{
object_172.key(key_173.as_str()).string(value_174.as_str());
}
}
object_172.finish();
}
if let Some(var_175) = &input.placement_group {
object.key("placementGroup").string(var_175.as_str());
}
if let Some(var_176) = &input.bid_percentage {
object.key("bidPercentage").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_176).into()),
);
}
if let Some(var_177) = &input.spot_iam_fleet_role {
object.key("spotIamFleetRole").string(var_177.as_str());
}
if let Some(var_178) = &input.launch_template {
#[allow(unused_mut)]
let mut object_179 = object.key("launchTemplate").start_object();
crate::json_ser::serialize_structure_crate_model_launch_template_specification(
&mut object_179,
var_178,
)?;
object_179.finish();
}
if let Some(var_180) = &input.ec2_configuration {
let mut array_181 = object.key("ec2Configuration").start_array();
for item_182 in var_180 {
{
#[allow(unused_mut)]
let mut object_183 = array_181.value().start_object();
crate::json_ser::serialize_structure_crate_model_ec2_configuration(
&mut object_183,
item_182,
)?;
object_183.finish();
}
}
array_181.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_eks_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EksConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_184) = &input.eks_cluster_arn {
object.key("eksClusterArn").string(var_184.as_str());
}
if let Some(var_185) = &input.kubernetes_namespace {
object.key("kubernetesNamespace").string(var_185.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_compute_environment_order(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComputeEnvironmentOrder,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_186) = &input.order {
object.key("order").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_186).into()),
);
}
if let Some(var_187) = &input.compute_environment {
object.key("computeEnvironment").string(var_187.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_fairshare_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FairsharePolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_188) = &input.share_decay_seconds {
object.key("shareDecaySeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_188).into()),
);
}
if let Some(var_189) = &input.compute_reservation {
object.key("computeReservation").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_189).into()),
);
}
if let Some(var_190) = &input.share_distribution {
let mut array_191 = object.key("shareDistribution").start_array();
for item_192 in var_190 {
{
#[allow(unused_mut)]
let mut object_193 = array_191.value().start_object();
crate::json_ser::serialize_structure_crate_model_share_attributes(
&mut object_193,
item_192,
)?;
object_193.finish();
}
}
array_191.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_key_values_pair(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KeyValuesPair,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_194) = &input.name {
object.key("name").string(var_194.as_str());
}
if let Some(var_195) = &input.values {
let mut array_196 = object.key("values").start_array();
for item_197 in var_195 {
{
array_196.value().string(item_197.as_str());
}
}
array_196.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_container_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ContainerProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_198) = &input.image {
object.key("image").string(var_198.as_str());
}
if let Some(var_199) = &input.vcpus {
object.key("vcpus").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_199).into()),
);
}
if let Some(var_200) = &input.memory {
object.key("memory").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_200).into()),
);
}
if let Some(var_201) = &input.command {
let mut array_202 = object.key("command").start_array();
for item_203 in var_201 {
{
array_202.value().string(item_203.as_str());
}
}
array_202.finish();
}
if let Some(var_204) = &input.job_role_arn {
object.key("jobRoleArn").string(var_204.as_str());
}
if let Some(var_205) = &input.execution_role_arn {
object.key("executionRoleArn").string(var_205.as_str());
}
if let Some(var_206) = &input.volumes {
let mut array_207 = object.key("volumes").start_array();
for item_208 in var_206 {
{
#[allow(unused_mut)]
let mut object_209 = array_207.value().start_object();
crate::json_ser::serialize_structure_crate_model_volume(&mut object_209, item_208)?;
object_209.finish();
}
}
array_207.finish();
}
if let Some(var_210) = &input.environment {
let mut array_211 = object.key("environment").start_array();
for item_212 in var_210 {
{
#[allow(unused_mut)]
let mut object_213 = array_211.value().start_object();
crate::json_ser::serialize_structure_crate_model_key_value_pair(
&mut object_213,
item_212,
)?;
object_213.finish();
}
}
array_211.finish();
}
if let Some(var_214) = &input.mount_points {
let mut array_215 = object.key("mountPoints").start_array();
for item_216 in var_214 {
{
#[allow(unused_mut)]
let mut object_217 = array_215.value().start_object();
crate::json_ser::serialize_structure_crate_model_mount_point(
&mut object_217,
item_216,
)?;
object_217.finish();
}
}
array_215.finish();
}
if let Some(var_218) = &input.readonly_root_filesystem {
object.key("readonlyRootFilesystem").boolean(*var_218);
}
if let Some(var_219) = &input.privileged {
object.key("privileged").boolean(*var_219);
}
if let Some(var_220) = &input.ulimits {
let mut array_221 = object.key("ulimits").start_array();
for item_222 in var_220 {
{
#[allow(unused_mut)]
let mut object_223 = array_221.value().start_object();
crate::json_ser::serialize_structure_crate_model_ulimit(&mut object_223, item_222)?;
object_223.finish();
}
}
array_221.finish();
}
if let Some(var_224) = &input.user {
object.key("user").string(var_224.as_str());
}
if let Some(var_225) = &input.instance_type {
object.key("instanceType").string(var_225.as_str());
}
if let Some(var_226) = &input.resource_requirements {
let mut array_227 = object.key("resourceRequirements").start_array();
for item_228 in var_226 {
{
#[allow(unused_mut)]
let mut object_229 = array_227.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_requirement(
&mut object_229,
item_228,
)?;
object_229.finish();
}
}
array_227.finish();
}
if let Some(var_230) = &input.linux_parameters {
#[allow(unused_mut)]
let mut object_231 = object.key("linuxParameters").start_object();
crate::json_ser::serialize_structure_crate_model_linux_parameters(
&mut object_231,
var_230,
)?;
object_231.finish();
}
if let Some(var_232) = &input.log_configuration {
#[allow(unused_mut)]
let mut object_233 = object.key("logConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_log_configuration(
&mut object_233,
var_232,
)?;
object_233.finish();
}
if let Some(var_234) = &input.secrets {
let mut array_235 = object.key("secrets").start_array();
for item_236 in var_234 {
{
#[allow(unused_mut)]
let mut object_237 = array_235.value().start_object();
crate::json_ser::serialize_structure_crate_model_secret(&mut object_237, item_236)?;
object_237.finish();
}
}
array_235.finish();
}
if let Some(var_238) = &input.network_configuration {
#[allow(unused_mut)]
let mut object_239 = object.key("networkConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_network_configuration(
&mut object_239,
var_238,
)?;
object_239.finish();
}
if let Some(var_240) = &input.fargate_platform_configuration {
#[allow(unused_mut)]
let mut object_241 = object.key("fargatePlatformConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_fargate_platform_configuration(
&mut object_241,
var_240,
)?;
object_241.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_eks_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EksProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_242) = &input.pod_properties {
#[allow(unused_mut)]
let mut object_243 = object.key("podProperties").start_object();
crate::json_ser::serialize_structure_crate_model_eks_pod_properties(
&mut object_243,
var_242,
)?;
object_243.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_node_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NodeProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_244) = &input.num_nodes {
object.key("numNodes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_244).into()),
);
}
if let Some(var_245) = &input.main_node {
object.key("mainNode").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_245).into()),
);
}
if let Some(var_246) = &input.node_range_properties {
let mut array_247 = object.key("nodeRangeProperties").start_array();
for item_248 in var_246 {
{
#[allow(unused_mut)]
let mut object_249 = array_247.value().start_object();
crate::json_ser::serialize_structure_crate_model_node_range_property(
&mut object_249,
item_248,
)?;
object_249.finish();
}
}
array_247.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_retry_strategy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RetryStrategy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_250) = &input.attempts {
object.key("attempts").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_250).into()),
);
}
if let Some(var_251) = &input.evaluate_on_exit {
let mut array_252 = object.key("evaluateOnExit").start_array();
for item_253 in var_251 {
{
#[allow(unused_mut)]
let mut object_254 = array_252.value().start_object();
crate::json_ser::serialize_structure_crate_model_evaluate_on_exit(
&mut object_254,
item_253,
)?;
object_254.finish();
}
}
array_252.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_job_timeout(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::JobTimeout,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_255) = &input.attempt_duration_seconds {
object.key("attemptDurationSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_255).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_array_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ArrayProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_256) = &input.size {
object.key("size").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_256).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_container_overrides(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ContainerOverrides,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_257) = &input.vcpus {
object.key("vcpus").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_257).into()),
);
}
if let Some(var_258) = &input.memory {
object.key("memory").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_258).into()),
);
}
if let Some(var_259) = &input.command {
let mut array_260 = object.key("command").start_array();
for item_261 in var_259 {
{
array_260.value().string(item_261.as_str());
}
}
array_260.finish();
}
if let Some(var_262) = &input.instance_type {
object.key("instanceType").string(var_262.as_str());
}
if let Some(var_263) = &input.environment {
let mut array_264 = object.key("environment").start_array();
for item_265 in var_263 {
{
#[allow(unused_mut)]
let mut object_266 = array_264.value().start_object();
crate::json_ser::serialize_structure_crate_model_key_value_pair(
&mut object_266,
item_265,
)?;
object_266.finish();
}
}
array_264.finish();
}
if let Some(var_267) = &input.resource_requirements {
let mut array_268 = object.key("resourceRequirements").start_array();
for item_269 in var_267 {
{
#[allow(unused_mut)]
let mut object_270 = array_268.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_requirement(
&mut object_270,
item_269,
)?;
object_270.finish();
}
}
array_268.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_job_dependency(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::JobDependency,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_271) = &input.job_id {
object.key("jobId").string(var_271.as_str());
}
if let Some(var_272) = &input.r#type {
object.key("type").string(var_272.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_eks_properties_override(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EksPropertiesOverride,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_273) = &input.pod_properties {
#[allow(unused_mut)]
let mut object_274 = object.key("podProperties").start_object();
crate::json_ser::serialize_structure_crate_model_eks_pod_properties_override(
&mut object_274,
var_273,
)?;
object_274.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_node_overrides(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NodeOverrides,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_275) = &input.num_nodes {
object.key("numNodes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_275).into()),
);
}
if let Some(var_276) = &input.node_property_overrides {
let mut array_277 = object.key("nodePropertyOverrides").start_array();
for item_278 in var_276 {
{
#[allow(unused_mut)]
let mut object_279 = array_277.value().start_object();
crate::json_ser::serialize_structure_crate_model_node_property_override(
&mut object_279,
item_278,
)?;
object_279.finish();
}
}
array_277.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_compute_resource_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComputeResourceUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_280) = &input.minv_cpus {
object.key("minvCpus").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_280).into()),
);
}
if let Some(var_281) = &input.maxv_cpus {
object.key("maxvCpus").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_281).into()),
);
}
if let Some(var_282) = &input.desiredv_cpus {
object.key("desiredvCpus").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_282).into()),
);
}
if let Some(var_283) = &input.subnets {
let mut array_284 = object.key("subnets").start_array();
for item_285 in var_283 {
{
array_284.value().string(item_285.as_str());
}
}
array_284.finish();
}
if let Some(var_286) = &input.security_group_ids {
let mut array_287 = object.key("securityGroupIds").start_array();
for item_288 in var_286 {
{
array_287.value().string(item_288.as_str());
}
}
array_287.finish();
}
if let Some(var_289) = &input.allocation_strategy {
object.key("allocationStrategy").string(var_289.as_str());
}
if let Some(var_290) = &input.instance_types {
let mut array_291 = object.key("instanceTypes").start_array();
for item_292 in var_290 {
{
array_291.value().string(item_292.as_str());
}
}
array_291.finish();
}
if let Some(var_293) = &input.ec2_key_pair {
object.key("ec2KeyPair").string(var_293.as_str());
}
if let Some(var_294) = &input.instance_role {
object.key("instanceRole").string(var_294.as_str());
}
if let Some(var_295) = &input.tags {
#[allow(unused_mut)]
let mut object_296 = object.key("tags").start_object();
for (key_297, value_298) in var_295 {
{
object_296.key(key_297.as_str()).string(value_298.as_str());
}
}
object_296.finish();
}
if let Some(var_299) = &input.placement_group {
object.key("placementGroup").string(var_299.as_str());
}
if let Some(var_300) = &input.bid_percentage {
object.key("bidPercentage").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_300).into()),
);
}
if let Some(var_301) = &input.launch_template {
#[allow(unused_mut)]
let mut object_302 = object.key("launchTemplate").start_object();
crate::json_ser::serialize_structure_crate_model_launch_template_specification(
&mut object_302,
var_301,
)?;
object_302.finish();
}
if let Some(var_303) = &input.ec2_configuration {
let mut array_304 = object.key("ec2Configuration").start_array();
for item_305 in var_303 {
{
#[allow(unused_mut)]
let mut object_306 = array_304.value().start_object();
crate::json_ser::serialize_structure_crate_model_ec2_configuration(
&mut object_306,
item_305,
)?;
object_306.finish();
}
}
array_304.finish();
}
if let Some(var_307) = &input.update_to_latest_image_version {
object.key("updateToLatestImageVersion").boolean(*var_307);
}
if let Some(var_308) = &input.r#type {
object.key("type").string(var_308.as_str());
}
if let Some(var_309) = &input.image_id {
object.key("imageId").string(var_309.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_update_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdatePolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_310) = &input.terminate_jobs_on_update {
object.key("terminateJobsOnUpdate").boolean(*var_310);
}
if input.job_execution_timeout_minutes != 0 {
object.key("jobExecutionTimeoutMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.job_execution_timeout_minutes).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_launch_template_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LaunchTemplateSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_311) = &input.launch_template_id {
object.key("launchTemplateId").string(var_311.as_str());
}
if let Some(var_312) = &input.launch_template_name {
object.key("launchTemplateName").string(var_312.as_str());
}
if let Some(var_313) = &input.version {
object.key("version").string(var_313.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_ec2_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Ec2Configuration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_314) = &input.image_type {
object.key("imageType").string(var_314.as_str());
}
if let Some(var_315) = &input.image_id_override {
object.key("imageIdOverride").string(var_315.as_str());
}
if let Some(var_316) = &input.image_kubernetes_version {
object
.key("imageKubernetesVersion")
.string(var_316.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_share_attributes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ShareAttributes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_317) = &input.share_identifier {
object.key("shareIdentifier").string(var_317.as_str());
}
if let Some(var_318) = &input.weight_factor {
object.key("weightFactor").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_318).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_volume(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Volume,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_319) = &input.host {
#[allow(unused_mut)]
let mut object_320 = object.key("host").start_object();
crate::json_ser::serialize_structure_crate_model_host(&mut object_320, var_319)?;
object_320.finish();
}
if let Some(var_321) = &input.name {
object.key("name").string(var_321.as_str());
}
if let Some(var_322) = &input.efs_volume_configuration {
#[allow(unused_mut)]
let mut object_323 = object.key("efsVolumeConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_efs_volume_configuration(
&mut object_323,
var_322,
)?;
object_323.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_key_value_pair(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KeyValuePair,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_324) = &input.name {
object.key("name").string(var_324.as_str());
}
if let Some(var_325) = &input.value {
object.key("value").string(var_325.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_mount_point(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MountPoint,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_326) = &input.container_path {
object.key("containerPath").string(var_326.as_str());
}
if let Some(var_327) = &input.read_only {
object.key("readOnly").boolean(*var_327);
}
if let Some(var_328) = &input.source_volume {
object.key("sourceVolume").string(var_328.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_ulimit(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Ulimit,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_329) = &input.hard_limit {
object.key("hardLimit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_329).into()),
);
}
if let Some(var_330) = &input.name {
object.key("name").string(var_330.as_str());
}
if let Some(var_331) = &input.soft_limit {
object.key("softLimit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_331).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_resource_requirement(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ResourceRequirement,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_332) = &input.value {
object.key("value").string(var_332.as_str());
}
if let Some(var_333) = &input.r#type {
object.key("type").string(var_333.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_linux_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LinuxParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_334) = &input.devices {
let mut array_335 = object.key("devices").start_array();
for item_336 in var_334 {
{
#[allow(unused_mut)]
let mut object_337 = array_335.value().start_object();
crate::json_ser::serialize_structure_crate_model_device(&mut object_337, item_336)?;
object_337.finish();
}
}
array_335.finish();
}
if let Some(var_338) = &input.init_process_enabled {
object.key("initProcessEnabled").boolean(*var_338);
}
if let Some(var_339) = &input.shared_memory_size {
object.key("sharedMemorySize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_339).into()),
);
}
if let Some(var_340) = &input.tmpfs {
let mut array_341 = object.key("tmpfs").start_array();
for item_342 in var_340 {
{
#[allow(unused_mut)]
let mut object_343 = array_341.value().start_object();
crate::json_ser::serialize_structure_crate_model_tmpfs(&mut object_343, item_342)?;
object_343.finish();
}
}
array_341.finish();
}
if let Some(var_344) = &input.max_swap {
object.key("maxSwap").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_344).into()),
);
}
if let Some(var_345) = &input.swappiness {
object.key("swappiness").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_345).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_log_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LogConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_346) = &input.log_driver {
object.key("logDriver").string(var_346.as_str());
}
if let Some(var_347) = &input.options {
#[allow(unused_mut)]
let mut object_348 = object.key("options").start_object();
for (key_349, value_350) in var_347 {
{
object_348.key(key_349.as_str()).string(value_350.as_str());
}
}
object_348.finish();
}
if let Some(var_351) = &input.secret_options {
let mut array_352 = object.key("secretOptions").start_array();
for item_353 in var_351 {
{
#[allow(unused_mut)]
let mut object_354 = array_352.value().start_object();
crate::json_ser::serialize_structure_crate_model_secret(&mut object_354, item_353)?;
object_354.finish();
}
}
array_352.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_secret(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Secret,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_355) = &input.name {
object.key("name").string(var_355.as_str());
}
if let Some(var_356) = &input.value_from {
object.key("valueFrom").string(var_356.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_network_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NetworkConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_357) = &input.assign_public_ip {
object.key("assignPublicIp").string(var_357.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_fargate_platform_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FargatePlatformConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_358) = &input.platform_version {
object.key("platformVersion").string(var_358.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_eks_pod_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EksPodProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_359) = &input.service_account_name {
object.key("serviceAccountName").string(var_359.as_str());
}
if let Some(var_360) = &input.host_network {
object.key("hostNetwork").boolean(*var_360);
}
if let Some(var_361) = &input.dns_policy {
object.key("dnsPolicy").string(var_361.as_str());
}
if let Some(var_362) = &input.containers {
let mut array_363 = object.key("containers").start_array();
for item_364 in var_362 {
{
#[allow(unused_mut)]
let mut object_365 = array_363.value().start_object();
crate::json_ser::serialize_structure_crate_model_eks_container(
&mut object_365,
item_364,
)?;
object_365.finish();
}
}
array_363.finish();
}
if let Some(var_366) = &input.volumes {
let mut array_367 = object.key("volumes").start_array();
for item_368 in var_366 {
{
#[allow(unused_mut)]
let mut object_369 = array_367.value().start_object();
crate::json_ser::serialize_structure_crate_model_eks_volume(
&mut object_369,
item_368,
)?;
object_369.finish();
}
}
array_367.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_node_range_property(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NodeRangeProperty,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_370) = &input.target_nodes {
object.key("targetNodes").string(var_370.as_str());
}
if let Some(var_371) = &input.container {
#[allow(unused_mut)]
let mut object_372 = object.key("container").start_object();
crate::json_ser::serialize_structure_crate_model_container_properties(
&mut object_372,
var_371,
)?;
object_372.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_evaluate_on_exit(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EvaluateOnExit,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_373) = &input.on_status_reason {
object.key("onStatusReason").string(var_373.as_str());
}
if let Some(var_374) = &input.on_reason {
object.key("onReason").string(var_374.as_str());
}
if let Some(var_375) = &input.on_exit_code {
object.key("onExitCode").string(var_375.as_str());
}
if let Some(var_376) = &input.action {
object.key("action").string(var_376.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_eks_pod_properties_override(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EksPodPropertiesOverride,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_377) = &input.containers {
let mut array_378 = object.key("containers").start_array();
for item_379 in var_377 {
{
#[allow(unused_mut)]
let mut object_380 = array_378.value().start_object();
crate::json_ser::serialize_structure_crate_model_eks_container_override(
&mut object_380,
item_379,
)?;
object_380.finish();
}
}
array_378.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_node_property_override(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NodePropertyOverride,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_381) = &input.target_nodes {
object.key("targetNodes").string(var_381.as_str());
}
if let Some(var_382) = &input.container_overrides {
#[allow(unused_mut)]
let mut object_383 = object.key("containerOverrides").start_object();
crate::json_ser::serialize_structure_crate_model_container_overrides(
&mut object_383,
var_382,
)?;
object_383.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_host(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Host,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_384) = &input.source_path {
object.key("sourcePath").string(var_384.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_efs_volume_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EfsVolumeConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_385) = &input.file_system_id {
object.key("fileSystemId").string(var_385.as_str());
}
if let Some(var_386) = &input.root_directory {
object.key("rootDirectory").string(var_386.as_str());
}
if let Some(var_387) = &input.transit_encryption {
object.key("transitEncryption").string(var_387.as_str());
}
if let Some(var_388) = &input.transit_encryption_port {
object.key("transitEncryptionPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_388).into()),
);
}
if let Some(var_389) = &input.authorization_config {
#[allow(unused_mut)]
let mut object_390 = object.key("authorizationConfig").start_object();
crate::json_ser::serialize_structure_crate_model_efs_authorization_config(
&mut object_390,
var_389,
)?;
object_390.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_device(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Device,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_391) = &input.host_path {
object.key("hostPath").string(var_391.as_str());
}
if let Some(var_392) = &input.container_path {
object.key("containerPath").string(var_392.as_str());
}
if let Some(var_393) = &input.permissions {
let mut array_394 = object.key("permissions").start_array();
for item_395 in var_393 {
{
array_394.value().string(item_395.as_str());
}
}
array_394.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tmpfs(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Tmpfs,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_396) = &input.container_path {
object.key("containerPath").string(var_396.as_str());
}
if let Some(var_397) = &input.size {
object.key("size").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_397).into()),
);
}
if let Some(var_398) = &input.mount_options {
let mut array_399 = object.key("mountOptions").start_array();
for item_400 in var_398 {
{
array_399.value().string(item_400.as_str());
}
}
array_399.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_eks_container(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EksContainer,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_401) = &input.name {
object.key("name").string(var_401.as_str());
}
if let Some(var_402) = &input.image {
object.key("image").string(var_402.as_str());
}
if let Some(var_403) = &input.image_pull_policy {
object.key("imagePullPolicy").string(var_403.as_str());
}
if let Some(var_404) = &input.command {
let mut array_405 = object.key("command").start_array();
for item_406 in var_404 {
{
array_405.value().string(item_406.as_str());
}
}
array_405.finish();
}
if let Some(var_407) = &input.args {
let mut array_408 = object.key("args").start_array();
for item_409 in var_407 {
{
array_408.value().string(item_409.as_str());
}
}
array_408.finish();
}
if let Some(var_410) = &input.env {
let mut array_411 = object.key("env").start_array();
for item_412 in var_410 {
{
#[allow(unused_mut)]
let mut object_413 = array_411.value().start_object();
crate::json_ser::serialize_structure_crate_model_eks_container_environment_variable(&mut object_413, item_412)?;
object_413.finish();
}
}
array_411.finish();
}
if let Some(var_414) = &input.resources {
#[allow(unused_mut)]
let mut object_415 = object.key("resources").start_object();
crate::json_ser::serialize_structure_crate_model_eks_container_resource_requirements(
&mut object_415,
var_414,
)?;
object_415.finish();
}
if let Some(var_416) = &input.volume_mounts {
let mut array_417 = object.key("volumeMounts").start_array();
for item_418 in var_416 {
{
#[allow(unused_mut)]
let mut object_419 = array_417.value().start_object();
crate::json_ser::serialize_structure_crate_model_eks_container_volume_mount(
&mut object_419,
item_418,
)?;
object_419.finish();
}
}
array_417.finish();
}
if let Some(var_420) = &input.security_context {
#[allow(unused_mut)]
let mut object_421 = object.key("securityContext").start_object();
crate::json_ser::serialize_structure_crate_model_eks_container_security_context(
&mut object_421,
var_420,
)?;
object_421.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_eks_volume(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EksVolume,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_422) = &input.name {
object.key("name").string(var_422.as_str());
}
if let Some(var_423) = &input.host_path {
#[allow(unused_mut)]
let mut object_424 = object.key("hostPath").start_object();
crate::json_ser::serialize_structure_crate_model_eks_host_path(&mut object_424, var_423)?;
object_424.finish();
}
if let Some(var_425) = &input.empty_dir {
#[allow(unused_mut)]
let mut object_426 = object.key("emptyDir").start_object();
crate::json_ser::serialize_structure_crate_model_eks_empty_dir(&mut object_426, var_425)?;
object_426.finish();
}
if let Some(var_427) = &input.secret {
#[allow(unused_mut)]
let mut object_428 = object.key("secret").start_object();
crate::json_ser::serialize_structure_crate_model_eks_secret(&mut object_428, var_427)?;
object_428.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_eks_container_override(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EksContainerOverride,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_429) = &input.image {
object.key("image").string(var_429.as_str());
}
if let Some(var_430) = &input.command {
let mut array_431 = object.key("command").start_array();
for item_432 in var_430 {
{
array_431.value().string(item_432.as_str());
}
}
array_431.finish();
}
if let Some(var_433) = &input.args {
let mut array_434 = object.key("args").start_array();
for item_435 in var_433 {
{
array_434.value().string(item_435.as_str());
}
}
array_434.finish();
}
if let Some(var_436) = &input.env {
let mut array_437 = object.key("env").start_array();
for item_438 in var_436 {
{
#[allow(unused_mut)]
let mut object_439 = array_437.value().start_object();
crate::json_ser::serialize_structure_crate_model_eks_container_environment_variable(&mut object_439, item_438)?;
object_439.finish();
}
}
array_437.finish();
}
if let Some(var_440) = &input.resources {
#[allow(unused_mut)]
let mut object_441 = object.key("resources").start_object();
crate::json_ser::serialize_structure_crate_model_eks_container_resource_requirements(
&mut object_441,
var_440,
)?;
object_441.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_efs_authorization_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EfsAuthorizationConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_442) = &input.access_point_id {
object.key("accessPointId").string(var_442.as_str());
}
if let Some(var_443) = &input.iam {
object.key("iam").string(var_443.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_eks_container_environment_variable(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EksContainerEnvironmentVariable,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_444) = &input.name {
object.key("name").string(var_444.as_str());
}
if let Some(var_445) = &input.value {
object.key("value").string(var_445.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_eks_container_resource_requirements(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EksContainerResourceRequirements,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_446) = &input.limits {
#[allow(unused_mut)]
let mut object_447 = object.key("limits").start_object();
for (key_448, value_449) in var_446 {
{
object_447.key(key_448.as_str()).string(value_449.as_str());
}
}
object_447.finish();
}
if let Some(var_450) = &input.requests {
#[allow(unused_mut)]
let mut object_451 = object.key("requests").start_object();
for (key_452, value_453) in var_450 {
{
object_451.key(key_452.as_str()).string(value_453.as_str());
}
}
object_451.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_eks_container_volume_mount(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EksContainerVolumeMount,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_454) = &input.name {
object.key("name").string(var_454.as_str());
}
if let Some(var_455) = &input.mount_path {
object.key("mountPath").string(var_455.as_str());
}
if let Some(var_456) = &input.read_only {
object.key("readOnly").boolean(*var_456);
}
Ok(())
}
pub fn serialize_structure_crate_model_eks_container_security_context(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EksContainerSecurityContext,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_457) = &input.run_as_user {
object.key("runAsUser").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_457).into()),
);
}
if let Some(var_458) = &input.run_as_group {
object.key("runAsGroup").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_458).into()),
);
}
if let Some(var_459) = &input.privileged {
object.key("privileged").boolean(*var_459);
}
if let Some(var_460) = &input.read_only_root_filesystem {
object.key("readOnlyRootFilesystem").boolean(*var_460);
}
if let Some(var_461) = &input.run_as_non_root {
object.key("runAsNonRoot").boolean(*var_461);
}
Ok(())
}
pub fn serialize_structure_crate_model_eks_host_path(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EksHostPath,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_462) = &input.path {
object.key("path").string(var_462.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_eks_empty_dir(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EksEmptyDir,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_463) = &input.medium {
object.key("medium").string(var_463.as_str());
}
if let Some(var_464) = &input.size_limit {
object.key("sizeLimit").string(var_464.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_eks_secret(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EksSecret,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_465) = &input.secret_name {
object.key("secretName").string(var_465.as_str());
}
if let Some(var_466) = &input.optional {
object.key("optional").boolean(*var_466);
}
Ok(())
}