aws-crons/dist/aws-crons.esm.js

A simple wrapper for creating cron jobs using scheduled tasks in AWS.

import { LambdaFunction } from '@aws-cdk/aws-events-targets';
import { Function } from '@aws-cdk/aws-lambda';
import { Rule } from '@aws-cdk/aws-events';
import { AwsLogDriver, FargateTaskDefinition } from '@aws-cdk/aws-ecs';
import { RemovalPolicy } from '@aws-cdk/core';
import { ScheduledFargateTask } from '@aws-cdk/aws-ecs-patterns';
import { LogGroup } from '@aws-cdk/aws-logs';

function _extends() {
  _extends = Object.assign || function (target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i];

      for (var key in source) {
        if (Object.prototype.hasOwnProperty.call(source, key)) {
          target[key] = source[key];
        }
      }
    }

    return target;
  };

  return _extends.apply(this, arguments);
}

var createLambdaCron = function createLambdaCron(_ref) {
  var stack = _ref.stack,
      vpc = _ref.vpc,
      id = _ref.id,
      lambdaProps = _ref.lambdaProps,
      eventRuleProps = _ref.eventRuleProps;

  try {
    var newLambda = new Function(stack, id, _extends({
      vpc: vpc
    }, lambdaProps));
    var newEventRule = new Rule(stack, id + "_rule", _extends({}, eventRuleProps));
    newEventRule.addTarget(new LambdaFunction(newLambda));
  } catch (error) {
    console.error(error);
    throw new Error('Something went wrong while creating lambda cron...');
  }
};

var createLogGroup = function createLogGroup(stack, id, props) {
  return new LogGroup(stack, id, props);
};
var createLogDriver = function createLogDriver(props) {
  return new AwsLogDriver(props);
};
var createCron = function createCron(stack, id, taskDefinition) {
  return new ScheduledFargateTask(stack, id, taskDefinition);
};

var createFargateCron = function createFargateCron(_ref) {
  var stack = _ref.stack,
      cluster = _ref.cluster,
      id = _ref.id,
      schedule = _ref.schedule,
      containerOptions = _ref.containerOptions,
      efsVolume = _ref.efsVolume,
      mountPoint = _ref.mountPoint;
  var logDriver = createLogDriver({
    streamPrefix: id,
    logGroup: createLogGroup(stack, id + "_logs", {
      logGroupName: id + "_logs",
      removalPolicy: RemovalPolicy.SNAPSHOT
    })
  });
  var ftd = new FargateTaskDefinition(stack, id + "_task", {});

  if (efsVolume) {
    ftd.addVolume(_extends({}, efsVolume));

    if (!mountPoint) {
      throw new Error('You must specify mount points for your EFS volume. \n mointPoints missing while efsVolume present');
    }
  }

  var container = ftd.addContainer(id + "_container", _extends({
    logging: logDriver
  }, containerOptions));

  if (mountPoint) {
    container.addMountPoints(_extends({}, mountPoint));
  }

  return createCron(stack, id + "_cron", {
    cluster: cluster,
    scheduledFargateTaskDefinitionOptions: {
      taskDefinition: ftd
    },
    schedule: schedule
  });
};

export { createFargateCron, createLambdaCron };
//# sourceMappingURL=aws-crons.esm.js.map