@cdklabs/cdk-ecs-codedeploy
Version:
CDK Constructs for performing ECS Deployments with CodeDeploy
172 lines (171 loc) • 7.86 kB
JavaScript
import { NormalizedSchema, SCHEMA } from "@smithy/core/schema";
import { splitEvery, splitHeader } from "@smithy/core/serde";
import { HttpRequest, HttpResponse } from "@smithy/protocol-http";
import { sdkStreamMixin } from "@smithy/util-stream";
import { collectBody } from "./collect-stream-body";
export class HttpProtocol {
constructor(options) {
this.options = options;
}
getRequestType() {
return HttpRequest;
}
getResponseType() {
return HttpResponse;
}
setSerdeContext(serdeContext) {
this.serdeContext = serdeContext;
this.serializer.setSerdeContext(serdeContext);
this.deserializer.setSerdeContext(serdeContext);
if (this.getPayloadCodec()) {
this.getPayloadCodec().setSerdeContext(serdeContext);
}
}
updateServiceEndpoint(request, endpoint) {
if ("url" in endpoint) {
request.protocol = endpoint.url.protocol;
request.hostname = endpoint.url.hostname;
request.port = endpoint.url.port ? Number(endpoint.url.port) : undefined;
request.path = endpoint.url.pathname;
request.fragment = endpoint.url.hash || void 0;
request.username = endpoint.url.username || void 0;
request.password = endpoint.url.password || void 0;
for (const [k, v] of endpoint.url.searchParams.entries()) {
if (!request.query) {
request.query = {};
}
request.query[k] = v;
}
return request;
}
else {
request.protocol = endpoint.protocol;
request.hostname = endpoint.hostname;
request.port = endpoint.port ? Number(endpoint.port) : undefined;
request.path = endpoint.path;
request.query = {
...endpoint.query,
};
return request;
}
}
setHostPrefix(request, operationSchema, input) {
const operationNs = NormalizedSchema.of(operationSchema);
const inputNs = NormalizedSchema.of(operationSchema.input);
if (operationNs.getMergedTraits().endpoint) {
let hostPrefix = operationNs.getMergedTraits().endpoint?.[0];
if (typeof hostPrefix === "string") {
const hostLabelInputs = [...inputNs.structIterator()].filter(([, member]) => member.getMergedTraits().hostLabel);
for (const [name] of hostLabelInputs) {
const replacement = input[name];
if (typeof replacement !== "string") {
throw new Error(`@smithy/core/schema - ${name} in input must be a string as hostLabel.`);
}
hostPrefix = hostPrefix.replace(`{${name}}`, replacement);
}
request.hostname = hostPrefix + request.hostname;
}
}
}
deserializeMetadata(output) {
return {
httpStatusCode: output.statusCode,
requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
extendedRequestId: output.headers["x-amz-id-2"],
cfId: output.headers["x-amz-cf-id"],
};
}
async deserializeHttpMessage(schema, context, response, arg4, arg5) {
let dataObject;
if (arg4 instanceof Set) {
dataObject = arg5;
}
else {
dataObject = arg4;
}
const deserializer = this.deserializer;
const ns = NormalizedSchema.of(schema);
const nonHttpBindingMembers = [];
for (const [memberName, memberSchema] of ns.structIterator()) {
const memberTraits = memberSchema.getMemberTraits();
if (memberTraits.httpPayload) {
const isStreaming = memberSchema.isStreaming();
if (isStreaming) {
const isEventStream = memberSchema.isStructSchema();
if (isEventStream) {
const context = this.serdeContext;
if (!context.eventStreamMarshaller) {
throw new Error("@smithy/core - HttpProtocol: eventStreamMarshaller missing in serdeContext.");
}
const memberSchemas = memberSchema.getMemberSchemas();
dataObject[memberName] = context.eventStreamMarshaller.deserialize(response.body, async (event) => {
const unionMember = Object.keys(event).find((key) => {
return key !== "__type";
}) ?? "";
if (unionMember in memberSchemas) {
const eventStreamSchema = memberSchemas[unionMember];
return {
[unionMember]: await deserializer.read(eventStreamSchema, event[unionMember].body),
};
}
else {
return {
$unknown: event,
};
}
});
}
else {
dataObject[memberName] = sdkStreamMixin(response.body);
}
}
else if (response.body) {
const bytes = await collectBody(response.body, context);
if (bytes.byteLength > 0) {
dataObject[memberName] = await deserializer.read(memberSchema, bytes);
}
}
}
else if (memberTraits.httpHeader) {
const key = String(memberTraits.httpHeader).toLowerCase();
const value = response.headers[key];
if (null != value) {
if (memberSchema.isListSchema()) {
const headerListValueSchema = memberSchema.getValueSchema();
let sections;
if (headerListValueSchema.isTimestampSchema() &&
headerListValueSchema.getSchema() === SCHEMA.TIMESTAMP_DEFAULT) {
sections = splitEvery(value, ",", 2);
}
else {
sections = splitHeader(value);
}
const list = [];
for (const section of sections) {
list.push(await deserializer.read([headerListValueSchema, { httpHeader: key }], section.trim()));
}
dataObject[memberName] = list;
}
else {
dataObject[memberName] = await deserializer.read(memberSchema, value);
}
}
}
else if (memberTraits.httpPrefixHeaders !== undefined) {
dataObject[memberName] = {};
for (const [header, value] of Object.entries(response.headers)) {
if (header.startsWith(memberTraits.httpPrefixHeaders)) {
dataObject[memberName][header.slice(memberTraits.httpPrefixHeaders.length)] = await deserializer.read([memberSchema.getValueSchema(), { httpHeader: header }], value);
}
}
}
else if (memberTraits.httpResponseCode) {
dataObject[memberName] = response.statusCode;
}
else {
nonHttpBindingMembers.push(memberName);
}
}
return nonHttpBindingMembers;
}
}