codegen: aws: SelectObjectContent (e4831a00) · Commits · Public Repositories / s3s

codegen/src/aws_conv.rs

+13 −3

Original line number	Diff line number	Diff line
		@@ -20,8 +20,10 @@ pub fn codegen(ops: &Operations, rust_types: &RustTypes, g: &mut Codegen) {
		]);

		for (name, rust_type) in rust_types {
		if name.starts_with("SelectObjectContent") {
		continue; // TODO: SelectObjectContent
		match name.as_str() {
		"SelectObjectContentRequest" => continue,
		"SelectObjectContentInput" => continue,
		_ => {}
		}

		match rust_type {
		@@ -62,7 +64,9 @@ pub fn codegen(ops: &Operations, rust_types: &RustTypes, g: &mut Codegen) {
		s => s,
		};

		if field.type_ == "StreamingBlob" {
		if field.type_ == "SelectObjectContentEventStream" {
		g.ln(f!("{s3s_field_name}: Some(crate::event_stream::from_aws(x.{aws_field_name})),"));
		} else if field.type_ == "StreamingBlob" {
		g.ln(f!("{s3s_field_name}: Some(try_from_aws(x.{aws_field_name})?),"));
		} else if field.option_type \|\| field.default_value.is_some() {
		g.ln(f!("{s3s_field_name}: try_from_aws(x.{aws_field_name})?,"));
		@@ -104,6 +108,11 @@ pub fn codegen(ops: &Operations, rust_types: &RustTypes, g: &mut Codegen) {
		}
		g.ln("fn try_into_aws(x: Self) -> S3Result<Self::Target> {");
		match rust_type {
		rust::Type::Struct(ty) if ty.name == "SelectObjectContentOutput" => {
		// TODO(blocking): SelectObjectContentOutput::try_into_aws
		g.ln("drop(x);");
		g.ln("unimplemented!(\"See https://github.com/Nugine/s3s/issues/5\")");
		}
		rust::Type::Struct(ty) => {
		if ty.fields.is_empty() {
		g.ln("let _ = x;");
		@@ -168,6 +177,7 @@ fn aws_ty_name(name: &str) -> &str {
		"ObjectCannedACL" => "ObjectCannedAcl",
		"SSEKMS" => "Ssekms",
		"SSES3" => "Sses3",
		"SelectObjectContentEvent" => "SelectObjectContentEventStream",
		_ => name,
		}
		}

codegen/src/aws_proxy.rs

+21 −10

Original line number	Diff line number	Diff line
		@@ -25,10 +25,6 @@ pub fn codegen(ops: &Operations, rust_types: &RustTypes, g: &mut Codegen) {
		g.ln("impl S3 for Proxy {");

		for op in ops.values() {
		if op.name == "SelectObjectContent" {
		continue; // TODO: SelectObjectContent
		}

		let method_name = op.name.to_snake_case();
		let s3s_input = f!("s3s::dto::{}", op.input);
		let s3s_output = f!("s3s::dto::{}", op.output);
		@@ -43,12 +39,27 @@ pub fn codegen(ops: &Operations, rust_types: &RustTypes, g: &mut Codegen) {
		} else {
		g.ln(f!("let mut b = self.0.{method_name}();"));
		let rust::Type::Struct(ty) = &rust_types[op.input.as_str()] else { panic!() };
		for field in &ty.fields {
		let s3s_field_name = field.name.as_str();
		let aws_field_name = match s3s_field_name {

		let flattened_fields = if ty.name == "SelectObjectContentInput" {
		let rust::Type::Struct(flattened_ty) = &rust_types["SelectObjectContentRequest"] else { panic!() };
		flattened_ty.fields.as_slice()
		} else {
		&[]
		};

		for field in ty.fields.iter().chain(flattened_fields) {
		let s3s_field_name = match ty.name.as_str() {
		"SelectObjectContentInput" if field.name == "request" => continue,
		"SelectObjectContentInput" if field.position == "xml" => f!("request.{}", field.name),
		_ => field.name.clone(),
		};
		let aws_field_name = match ty.name.as_str() {
		"SelectObjectContentInput" => field.name.as_str(),
		_ => match s3s_field_name.as_str() {
		"checksum_crc32c" => "checksum_crc32_c",
		"type_" => "type",
		s => s,
		},
		};

		// // hack

crates/s3s-aws/Cargo.toml

+3 −1

Original line number	Diff line number	Diff line
		@@ -12,11 +12,13 @@ categories = ["web-programming", "web-programming::http-server"]
		[dependencies]
		async-trait = "0.1.63"
		aws-sdk-s3 = "0.24.0"
		aws-smithy-http = "0.54.1"
		aws-smithy-http = { version = "0.54.1", features = ["event-stream"] }
		aws-smithy-types = "0.54.1"
		aws-smithy-types-convert = { version = "0.54.1", features = ["convert-time"] }
		bytes = "1.3.0"
		futures = { version = "0.3.25", default-features = false, features = ["std"] }
		hyper = "0.14.23"
		s3s = { version = "0.3.0-dev", path = "../s3s" }
		sync_wrapper = "0.1.2"
		tracing = "0.1.37"
		transform-stream = "0.3.0"

crates/s3s-aws/src/conv/builtin.rs

+43 −0

Original line number	Diff line number	Diff line
		@@ -149,3 +149,46 @@ impl AwsConversion for s3s::dto::Body {
		Ok(Self::Target::new(x))
		}
		}

		impl AwsConversion for s3s::dto::SelectObjectContentInput {
		type Target = aws_sdk_s3::input::SelectObjectContentInput;

		type Error = S3Error;

		fn try_from_aws(x: Self::Target) -> Result<Self, Self::Error> {
		Ok(Self {
		bucket: unwrap_from_aws(x.bucket, "bucket")?,
		expected_bucket_owner: x.expected_bucket_owner,
		key: unwrap_from_aws(x.key, "key")?,
		sse_customer_algorithm: x.sse_customer_algorithm,
		sse_customer_key: x.sse_customer_key,
		sse_customer_key_md5: x.sse_customer_key_md5,
		request: s3s::dto::SelectObjectContentRequest {
		expression: unwrap_from_aws(x.expression, "expression")?,
		expression_type: unwrap_from_aws(x.expression_type, "expression_type")?,
		input_serialization: unwrap_from_aws(x.input_serialization, "input_serialization")?,
		output_serialization: unwrap_from_aws(x.output_serialization, "output_serialization")?,
		request_progress: try_from_aws(x.request_progress)?,
		scan_range: try_from_aws(x.scan_range)?,
		},
		})
		}

		fn try_into_aws(x: Self) -> Result<Self::Target, Self::Error> {
		aws_sdk_s3::input::SelectObjectContentInput::builder()
		.set_bucket(Some(x.bucket))
		.set_expected_bucket_owner(x.expected_bucket_owner)
		.set_key(Some(x.key))
		.set_sse_customer_algorithm(x.sse_customer_algorithm)
		.set_sse_customer_key(x.sse_customer_key)
		.set_sse_customer_key_md5(x.sse_customer_key_md5)
		.set_expression(Some(x.request.expression))
		.set_expression_type(Some(try_into_aws(x.request.expression_type)?))
		.set_input_serialization(Some(try_into_aws(x.request.input_serialization)?))
		.set_output_serialization(Some(try_into_aws(x.request.output_serialization)?))
		.set_request_progress(try_into_aws(x.request.request_progress)?)
		.set_scan_range(try_into_aws(x.request.scan_range)?)
		.build()
		.map_err(S3Error::internal_error)
		}
		}

crates/s3s-aws/src/conv/generated.rs

+43 −0

Original line number	Diff line number	Diff line
		@@ -7683,6 +7683,49 @@ impl AwsConversion for s3s::dto::ScanRange {
		}
		}

		impl AwsConversion for s3s::dto::SelectObjectContentEvent {
		type Target = SelectObjectContentEventStream;
		type Error = S3Error;

		fn try_from_aws(x: Self::Target) -> S3Result<Self> {
		Ok(match x {
		SelectObjectContentEventStream::Cont(v) => Self::Cont(try_from_aws(v)?),
		SelectObjectContentEventStream::End(v) => Self::End(try_from_aws(v)?),
		SelectObjectContentEventStream::Progress(v) => Self::Progress(try_from_aws(v)?),
		SelectObjectContentEventStream::Records(v) => Self::Records(try_from_aws(v)?),
		SelectObjectContentEventStream::Stats(v) => Self::Stats(try_from_aws(v)?),
		_ => unimplemented!("unknown variant of SelectObjectContentEventStream: {x:?}"),
		})
		}

		fn try_into_aws(x: Self) -> S3Result<Self::Target> {
		Ok(match x {
		Self::Cont(v) => SelectObjectContentEventStream::Cont(try_into_aws(v)?),
		Self::End(v) => SelectObjectContentEventStream::End(try_into_aws(v)?),
		Self::Progress(v) => SelectObjectContentEventStream::Progress(try_into_aws(v)?),
		Self::Records(v) => SelectObjectContentEventStream::Records(try_into_aws(v)?),
		Self::Stats(v) => SelectObjectContentEventStream::Stats(try_into_aws(v)?),
		_ => unimplemented!("unknown variant of SelectObjectContentEvent: {x:?}"),
		})
		}
		}

		impl AwsConversion for s3s::dto::SelectObjectContentOutput {
		type Target = SelectObjectContentOutput;
		type Error = S3Error;

		fn try_from_aws(x: Self::Target) -> S3Result<Self> {
		Ok(Self {
		payload: Some(crate::event_stream::from_aws(x.payload)),
		})
		}

		fn try_into_aws(x: Self) -> S3Result<Self::Target> {
		drop(x);
		unimplemented!("See https://github.com/Nugine/s3s/issues/5")
		}
		}

		impl AwsConversion for s3s::dto::SelectParameters {
		type Target = SelectParameters;
		type Error = S3Error;