cloud-red/src/components/editor-api/lib/admin/flows.js

Harnessing Serverless for your cloud integration needs

/**
 * Copyright JS Foundation and other contributors, http://js.foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * 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 runtimeAPI;
const apiUtils = require('../util');
const { AWSProvider } = require('../../../editor-cloud-providers/AwsProvider');
const { userSettings } = require('..');
const RED = require('../../../../core/lib/red.js');
let deploying = false;

module.exports = {
  init: function(_runtimeAPI) {
    runtimeAPI = _runtimeAPI;
  },
  get: function(req, res) {
    var version = req.get('Node-RED-API-Version') || 'v1';
    if (!/^v[12]$/.test(version)) {
      return res.status(400).json({
        code: 'invalid_api_version',
        message: 'Invalid API Version requested'
      });
    }
    var opts = {
      user: req.user
    };
    runtimeAPI.flows
      .getFlows(opts)
      .then(function(result) {
        if (version === 'v1') {
          res.json(result.flows);
        } else if (version === 'v2') {
          res.json(result);
        }
      })
      .catch(function(err) {
        apiUtils.rejectHandler(req, res, err);
      });
  },
  post: async function(req, res) {
    var version = req.get('Node-RED-API-Version') || 'v1';
    if (!/^v[12]$/.test(version)) {
      return res.status(400).json({
        code: 'invalid_api_version',
        message: 'Invalid API Version requested'
      });
    }
    var opts = {
      user: req.user,
      deploymentType: req.get('Node-RED-Deployment-Type') || 'full'
    };

    if (opts.deploymentType !== 'reload') {
      if (version === 'v1') {
        opts.flows = { flows: req.body };
      } else {
        opts.flows = req.body;
      }
    }

    const runtimeSettings = await runtimeAPI.settings.getRuntimeSettings();
    const userDir = runtimeSettings.userDir;
    const userSettings = await runtimeAPI.settings.getUserSettings();
    const cloudRedSettings = userSettings.cloudred;

    const enviroSelected = cloudRedSettings.environment.filter(
      e => e.status === 'current'
    );

    if (enviroSelected[0].envname === 'localhost') {
      // localhost deployment
      RED.log.info('Local deployment triggered');

      runtimeAPI.flows
        .setFlows(opts)
        .then(function(result) {
          RED.events.emit('editor:post-local-deployment');
          if (version === 'v1') {
            res.status(204).end();
          } else {
            res.json(result);
          }
        })
        .catch(function(err) {
          apiUtils.rejectHandler(req, res, err);
        });
    } else {
      // cloud deployment
      const awsProfile = enviroSelected[0].profile;
      const lambdaSettings = cloudRedSettings.function;
      if (!lambdaSettings.name) {
        apiUtils.rejectHandler(
          req,
          res,
          new Error('Lambda name must be specified. Go to settings > Lambda')
        );
      }
      // ensure only one deployment called is being invoked at a time.
      if (deploying) {
        return res.status(429).json({
          code: 'Too many requests',
          message: 'Only one deployment request can be processed concurrently'
        });
      } else {
        deploying = true;
      }
      RED.log.info(
        `Cloud deployment triggered (aws-profile: ${awsProfile}) ...`
      );

      const aws = new AWSProvider(
        userDir,
        lambdaSettings.name,
        'lambda.handler', // TODO: jteso - include this on the settings
        null, // version
        awsProfile,
        'ap-southeast-2', // TODO: jteso - include this on the settings
        lambdaSettings.timeout,
        lambdaSettings.memory,
        null, // runtime
        null // env
      );

      const newFlow = opts.flows.flows;
      runtimeAPI.flows
        .setFlows(opts)
        .then(() => {
          aws
            .createDeployment(newFlow)
            .then(() => {
              RED.events.emit('editor:post-deployment');
              deploying = false;
              res.status(200).end();
            })
            .catch(err => {
              deploying = false;
              apiUtils.rejectHandler(req, res, err);
            });
        })
        .catch(function(err) {
          deploying = false;
          apiUtils.rejectHandler(req, res, err);
        });
    }
  }
};