carbonless.js

'use strict';

const fs = require('fs');
const path = require('path');
 
class Carbonless {    
    constructor(serverless, options, { log }) {
        this.serverless = serverless;
        this.log = log;
        this.provider = this.serverless.getProvider('aws');
        this.hooks = {
            'after:package:initialize': () => this.afterInitialize(),
            'deploy:deploy': () => this.deploy(),
        };
    }
    
    afterInitialize(){
        this.addCarbonRouterRole();
        this.addCarbonRouterForEachLambda();
    }

    deploy(){
        this.copyLambdasToOtherRegions();
    }

    addCarbonRouterRole(){
        if (typeof this.serverless.service.resources !== 'object') {
            this.serverless.service.resources = {};
        }
        if (typeof this.serverless.service.resources.Resources !== 'object') {
            this.serverless.service.resources.Resources = {};
        }
        this.serverless.service.resources.Resources['CarbonRouterRole'] = {
            Type: 'AWS::IAM::Role',
            Properties: {
              Path: '/',
              RoleName: 'CarbonRouterRole',
              AssumeRolePolicyDocument: {
                Version: '2012-10-17',
                Statement: [
                  {
                    Effect: 'Allow',
                    Principal: {
                      Service: [
                        'lambda.amazonaws.com',
                      ],
                    },
                    Action: 'sts:AssumeRole',
                  },
                ],
              },
              Policies: [
                {
                  PolicyName: 'CarbonRouterPolicy',
                  PolicyDocument: {
                    Version: '2012-10-17',
                    Statement: [
                      {
                        Effect: 'Allow',
                        Action: [
                          'lambda:GetFunction',
                          'lambda:InvokeFunction',
                        ],
                        Resource: '*',
                      },
                    ],
                  },
                },
              ],
            },
          };
    }

    addCarbonRouterForEachLambda(){
        this.serverless.service.getAllFunctions().forEach((functionName) => {
            const functionObj = this.serverless.service.getFunction(functionName);
            const handlerFolder = path.join(this.serverless.serviceDir, '.carbonless');
            this.createCarbonlessRouterFunctionArtifact(functionName, functionObj, handlerFolder);
            this.addCarbonlessRouterFunctionToService(functionName, functionObj);
        });
    }

    createCarbonlessRouterFunctionArtifact(functionName, functionObj, handlerFolder) {
        const carbonlessRouterFunction = `'use strict';

/** Generated by Serverless Plugin Carbonless **/

module.exports.carbonlessRouter = async (event) => {
    const aws = require('aws-sdk');
    
    // Check where function is deployed
    const regions = ['us-east-1', 'eu-west-1'];
    const awsToAzureRegionsMap = {'us-east-1':'eastus', 'eu-west-1':'westeurope'}
    const regionsWithFunction = [];
    for (let i=0; i < regions.length; i++){
        const lambda = new aws.Lambda({region: regions[i]});
        try{
            const result = await lambda.getFunction({FunctionName: 'example-serverless-dev-hello'}).promise();
            // If doesn't throw error then function is in this region
            regionsWithFunction.push(regions[i]);
        } catch (err){
            // function not in this region
        }
    }
    
    console.log(\`Regions with function example-serverless-dev-hello are \${regionsWithFunction}\`)

    // Check where carbon intensity is lowest
    let bestRegion;
    let minCarbonIntensity;
    for (let i=0; i < regionsWithFunction.length; i++){
        try {
            const result = await getRegionCarbonIntensity(awsToAzureRegionsMap[regionsWithFunction[i]]);
            const carbonIntensity = result[0]['forecastData'][0]['value'];
            console.log(\`carbonIntensity in \${regionsWithFunction[i]} is \${carbonIntensity}\`);
            if (minCarbonIntensity){
                if (carbonIntensity < minCarbonIntensity){
                    bestRegion = regionsWithFunction[i];
                }
            } else {
                bestRegion = regionsWithFunction[i];
                minCarbonIntensity = carbonIntensity;
            }
        } catch (error){
            console.log(error);
        }   
    }
    
    console.log(\`bestRegion is \${bestRegion}\`);
    
    // Invoke function in best region
    const lambda = new aws.Lambda({region: bestRegion}); 
    const res = await lambda.invoke({FunctionName: 'example-serverless-dev-hello', Payload: JSON.stringify(event, null, 2)}).promise();
    console.log(\`Invoked function example-serverless-dev-hello in region \${bestRegion}\`)
    return res;
};

function getRegionCarbonIntensity(region) {
    const https = require('https');
    const forecastAPI = 'https://carbon-aware-api.azurewebsites.net/emissions/forecasts/current';
    const minutes = 10;
    const dataEndAt = new Date(Date.now() + minutes*60000).toISOString();
    
    return new Promise((resolve, reject) => {
        const req = https.get(forecastAPI + \`?location=\${region}&dataEndAt=\${dataEndAt}\`, (res) => {
            let data = '';
            res.on('data', chunk => {
                data += chunk;
            });
            res.on('end', () => {
                try {
                  resolve(JSON.parse(data));
                } catch (err) {
                  reject(new Error(err));
                }
            });
        });
        req.on('error', err => {
            reject(new Error(err));
        });
    });
}`;
      
        /** Write carbonless router file */
        fs.mkdirSync(handlerFolder, { recursive: true });
        fs.writeFileSync(path.join(handlerFolder, `${functionName}.js`), carbonlessRouterFunction);
      }

    addCarbonlessRouterFunctionToService(functionName, functionObj){
        const service = this.serverless.service;
        service.functions[`${functionName}CarbonlessRouter`] = {  
            handler: `.carbonless/${functionName}.carbonlessRouter`,
            events: functionObj.events,
            name: `${functionObj.name}-carbonless-router`,
            package: {},
            memory: 1024,
            timeout: 6,
            runtime: 'nodejs14.x',
            roleName: 'CarbonRouterRole',
            role: 'CarbonRouterRole'
        };
        service.functions[functionName].events = [];
    }

    copyLambdasToOtherRegions(){
        let functions = this.serverless.service.functions;
        Object.values(functions).forEach((functionObj) => {
            if(!functionObj.name.includes('-carbonless-router'))
            this.copyLambdaToOtherRegions(functionObj);
        })
    }

    copyLambdaToOtherRegions(functionObj){
        // Todo get regions dynamically
        const regions = ['eu-west-1'];
        regions.forEach(async (region) => {
            // Todo check if function exists in region
            const account = await this.provider.getAccountInfo();
            const lambdaExecutionARN = `arn:${account.partition}:iam::${account.accountId}:role/${this.provider.serverless.service.service}-${this.provider.getStage()}-${this.provider.getRegion()}-lambdaRole`;
            const data = fs.readFileSync(this.serverless.service.package.artifact);
            const params = {
                FunctionName: functionObj.name,
                Handler: functionObj.handler,
                Role: lambdaExecutionARN,
                Runtime: functionObj.runtime,
                Code: {
                  ZipFile: data
                }
              };
            this.provider.request(
                'Lambda',
                'createFunction',
                params,
                { region: region }
            );
            this.log.notice(`Copied Lambda to ${region}`)
        });
    }
}
 
module.exports = Carbonless;