@pulumi/awsx
Version:
[](https://github.com/pulumi/pulumi-awsx/actions) [](https://slack.pulumi.com) [;
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.TargetGroupAttachment = void 0;
// tslint:disable:max-line-length
const aws = __importStar(require("@pulumi/aws"));
const pulumi = __importStar(require("@pulumi/pulumi"));
const loadBalancer_1 = require("./loadBalancer");
class TargetGroupAttachment extends pulumi.ComponentResource {
targetGroupAttachment;
permission;
func;
constructor(name, targetGroup, args, opts = {}) {
opts = pulumi.mergeOptions(opts, { aliases: [{ type: "awsx:elasticloadbalancingv2:TargetGroupAttachment" }] });
super("awsx:lb:TargetGroupAttachment", name, undefined, { parent: targetGroup, ...opts });
const { targetInfo, func, permission } = getTargetInfo(this, targetGroup, name, args);
const dependsOn = permission ? [permission] : [];
this.targetGroupAttachment = new aws.lb.TargetGroupAttachment(name, {
availabilityZone: targetInfo.availabilityZone,
port: targetInfo.port,
targetGroupArn: targetGroup.targetGroup.arn,
targetId: targetInfo.targetId,
}, { parent: this, dependsOn });
this.func = func;
this.permission = permission;
this.registerOutputs();
}
}
exports.TargetGroupAttachment = TargetGroupAttachment;
function getTargetInfo(parent, targetGroup, name, args) {
if (aws.ec2.Instance.isInstance(args)) {
return { targetInfo: getEc2InstanceTargetInfo(targetGroup, args), permission: undefined, func: undefined };
}
if (aws.lambda.Function.isInstance(args)) {
return getLambdaFunctionTargetInfo(parent, targetGroup, name, args);
}
if (args instanceof Function) {
return getLambdaFunctionTargetInfo(parent, targetGroup, name, new aws.lambda.CallbackFunction(name, { callback: args }, { parent }));
}
if ((0, loadBalancer_1.isLoadBalancerTargetInfoProvider)(args)) {
const targetType = targetGroup.targetGroup.targetType;
return { targetInfo: args.loadBalancerTargetInfo(targetType), permission: undefined, func: undefined };
}
return { targetInfo: pulumi.output(args), permission: undefined, func: undefined };
}
/**
* Allows an EC2 instance to simply be used as the target of an ALB or NLB. To use, just call:
*/
function getEc2InstanceTargetInfo(targetGroup, instance) {
const targetInfo = pulumi.output([targetGroup.targetGroup.targetType, instance.id, instance.privateIp, instance.availabilityZone])
.apply(([targetType, instanceId, privateIp, availabilityZone]) => {
if (targetType === "lambda") {
throw new pulumi.ResourceError("Cannot connect a [TargetGroup] with type [lambda] to an ec2.Instance", targetGroup);
}
return {
targetId: targetType === "instance" ? instanceId : privateIp,
availabilityZone: availabilityZone,
};
});
return targetInfo;
}
/**
* Allows a Lambda to simply be used as the target of an ALB. To use, just call:
*/
function getLambdaFunctionTargetInfo(parent, targetGroup, name, func) {
const permission = new aws.lambda.Permission(name, {
action: "lambda:InvokeFunction",
function: func,
principal: "elasticloadbalancing.amazonaws.com",
sourceArn: targetGroup.targetGroup.arn,
}, { parent });
const targetInfo = pulumi.output([targetGroup.targetGroup.targetType, func.arn])
.apply(([targetType, lambdaArn]) => {
if (targetType !== "lambda") {
throw new pulumi.ResourceError("Can only connect a [TargetGroup] with type [lambda] to an aws.lambda.Function", targetGroup);
}
return {
targetId: lambdaArn,
};
});
return { targetInfo, func, permission };
}
//# sourceMappingURL=targetGroupAttachment.js.map