如何确保我的变量在被不同路径使用时被初始化？

问题描述

我的API有2条不同的路由：

• 最终用户的1，他们在其中发布所需的数据，然后触发GitLab管道，在该管道中，我在管道中获取触发的管道ID和作业ID。
• 1是用于我集成的GitLab Webhook。

我有2个变量：pipelineId和jobId。它们是全局变量，因为我在两条路径中都使用它们。它们最初都是空的，然后在第一个路径中初始化。

第一个路由在触发后在响应主体中获取它们，我想使用它们在第二个路由中获取特定作业的日志。但是，由于两个路由都并行执行，因此我最终得到了空变量。现在，我的问题是如何确保在第二条路径中使用变量时，第一条路径会初始化我的变量。

这是我正在处理的代码：

const axios = require('axios');
const api = require('lambda-api')();
let FormData = require('form-data');

let PROJECT_ID_CREATE = process.env.PROJECT_ID_CREATE
let PROJECT_ID_DESTROY = process.env.PROJECT_ID_DESTROY
let CREATE_TOKEN = process.env.CREATE_TOKEN
let DESTROY_TOKEN = process.env.DESTROY_TOKEN
let PRIVATE_TOKEN = process.env.PRIVATE_TOKEN
let pipelineId = ""
let jobId = ""
let ec2InstanceLink = ""
let config = ""
// First route where the end user posts their data
api.post('/api-gitlab-launcher/create',async (lambdaRequest,res) => {
        //Trigger pipelines
        await axios.post(`https://gitlab.com/api/v4/projects/${PROJECT_ID_CREATE}/trigger/pipeline?token=${CREATE_TOKEN}&ref=terraform-v1-mirror`)
            .then(async (gitlabPOSTResponse) => {
                    pipelineId = gitlabPOSTResponse.data.id
                    console.log(`pipeline_id = ${pipelineId}`)
                },(error) => {
                    console.log(error)
                }
            )

        config = {
            method: 'GET',url: `https://gitlab.com/api/v4/projects/${PROJECT_ID_CREATE}/pipelines/${pipelineId}/jobs`,headers: {
                "PRIVATE-TOKEN": PRIVATE_TOKEN
            }
        }
        //Get Job Id
        await axios(config)
            .then(async (gitlabGETResponse) => {
                    for (let gitlabGETResponseKey in gitlabGETResponse.data) {
                        if (gitlabGETResponse.data[gitlabGETResponseKey].name === 'apply') {
                            jobId = JSON.stringify(gitlabGETResponse.data[gitlabGETResponseKey].id);
                            console.log(`Job id : ${JSON.stringify(gitlabGETResponse.data[gitlabGETResponseKey].id)}`)
                        }
                    }
                },(error) => {
                    console.log(error)
                }
            )
        config = {
            method: 'GET',url: `https://gitlab.com/api/v4/projects/${PROJECT_ID_CREATE}/jobs/${jobId}`,headers: {
                "PRIVATE-TOKEN": PRIVATE_TOKEN
            }
        }
        //Get Job Logs using Job Id
        await axios(config)
            .then((getJobLogsResponse) => {
                    let jobLog = JSON.stringify(getJobLogsResponse.data)
                    ec2InstanceLink = jobLog.match('https:(...)*\.(...)*\.com\:8443')
                    console.log(`Link in Job Log : ${ec2InstanceLink}`)
                }
            )

        /*let data = new FormData();
        data.append('token',DESTROY_TOKEN);
        data.append('ref','terraform-v1');
        data.append('variables[LAST_PIPELINE_ID]',pipelineId);

        config = {
            method: 'POST',url: `https://gitlab.com/api/v4/projects/${PROJECT_ID_DESTROY}/trigger/pipeline`,data: data,headers: {
                ...data.getHeaders()
            }
        }
        await axios(config)
            .then(
                () => {
                    console.log("Resources destroyed.")
                },(error) => {
                    console.log(`error : ${error}`)
                }
            )*/
    }
)
// 2nd route where the gitlab webhook posts the job events
api.post('/api-gitlab-launcher/gitlab-webhook',async (gitlabRequest,res) => {
        if (pipelineId != '') {
            if (gitlabRequest.body["pipeline_id"] === pipelineId) {
                if (gitlabRequest.body["build_id"] === jobId) {
                    if (gitlabRequest.body["build_status"] === 'success') {
                        config = {
                            method: 'GET',headers: {
                                "PRIVATE-TOKEN": PRIVATE_TOKEN
                            }
                        }
                        //Get Job Logs using Job Id
                        await axios(config)
                            .then((getJobLogsRequest) => {
                                    let jobLog = JSON.stringify(getJobLogsRequest.data)
                                    //ec2InstanceLink = jobLog.match('https:(...)*\.(...)*\.com\:8443')
                                    console.log(`Link in Job Log : ${jobLog}`)
                                }
                            )
                    } else {
                        console.log("wrong status")
                    }
                } else {
                    console.log(`wrong job job_id in log : ${gitlabRequest.body["build_id"]} and my job_id : ${jobId}`)
                }
            } else {
                console.log(`wrong pipeline pipeline_id in log : ${gitlabRequest.body["pipeline_id"]} and my pipeline_id : ${pipelineId}`)
            }
        }
    }
)

exports.handler = async (event,context) => {
    return await api.run(event,context);
}

解决方法

由于第二次调用取决于从第一次调用中检索到的信息，因此您需要将它们链接起来，以便它们按顺序执行，而不是并行执行。

例如，将调用＃2包装在一个函数中，然后从完整的处理程序（在其中设置pipelineId）中调用该函数。