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

Question

我的 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',
                            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((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);
}

Answer 1

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

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