Skapa en statusserver för pull-begäran med Node.js

Artikel
04/04/2024

Azure DevOps Services | Azure DevOps Server 2022 – Azure DevOps Server 2019

Arbetsflödet för pull-begäran (PR) ger utvecklare möjlighet att få feedback om sin kod från peer-datorer samt från automatiserade verktyg. Verktyg och tjänster från tredje part kan delta i PR-arbetsflödet med hjälp av API:et FÖR PR-status. Den här artikeln vägleder dig genom processen med att skapa en statusserver för att validera prs på en Azure DevOps Services Git-lagringsplats. Mer information om PR-status finns i Anpassa och utöka arbetsflöden för pull-begäranden med pull-begärandestatus.

Förutsättningar

En organisation i Azure DevOps med en Git-lagringsplats. Om du inte har en organisation kan du registrera dig för att ladda upp och dela kod i kostnadsfria obegränsade privata Git-lagringsplatser.
Installera VALFRI VS Code eller någon annan kodredigerare. Anvisningarna i den här guiden använder VS Code, men stegen i andra kodredigerare är liknande.

Installera Node.js

Om du vill installera Node.js laddar du ned LTS-versionen som är lämplig för din plattform. Nedladdningen innehåller ett installationsprogram som du kan köra för att installera Node.js-körningen på den lokala datorn. När du installerar Node.js måste du behålla npm-pakethanterarens del av installationen, som är markerad som standard.

Skapa en grundläggande webbserver med Express

Stegen i det här avsnittet använder Express, som är ett enkelt webbramverk för Node.js som tillhandahåller ett antal HTTP-verktygsmetoder som förenklar skapandet av en webbserver. Det här ramverket ger dig de grundläggande funktioner som behövs för att lyssna på PR-händelser.

Skapa en ny projektmapp för webbservern på kommandoraden.
```
mkdir pr-server
cd pr-server
```
npm init Använd kommandot för att skapa en ny package.json fil för projektet.
```
npm init
```
Tryck på Retur för att acceptera standardinställningarna för alla alternativ förutom startpunkten. Ändra den till app.js
```
entry point: (index.js) app.js
```
Installera Express i pr-server-katalogen med hjälp av följande kommando. Detta installerar Express och sparar det i listan med beroenden.
```
npm install express
```
Skapa en enkel Express-app att bygga vidare på för PR-statusservern. Följande steg baseras på Express Hello World-exemplet. Öppna projektmappen i VS Code genom att köra följande kommando från pr-server mappen.
```
code .
```

Skapa en ny fil (Ctrl + N) och klistra in följande exempelkod.

const express = require('express')
const app = express()

app.get('/', function (req, res) {
res.send('Hello World!')
})

app.listen(3000, function () {
console.log('Example app listening on port 3000!')
})

Spara filen som app.js.
Kör den grundläggande webbservern med följande kommando:
```
node app.js
```
Kontrollera att servern körs genom att bläddra till http://localhost:3000/.

Lyssna efter HTTP POST-begäranden

Webbservern kommer att ta emot POST begäranden från Azure DevOps Services, så du måste hantera dessa begäranden på servern.

I slutet av app.js filen lägger du till följande kod och sparar filen.

app.post('/', function (req, res) {
    res.send('Received the POST')
})

Kör webbservern igen med följande kommando:
```
node app.js
```

Konfigurera en tjänstkrok för PR-händelser

Tjänstkrokar är en Azure DevOps Services-funktion som kan varna externa tjänster när vissa händelser inträffar. I det här exemplet vill du konfigurera två tjänstkrokar för PR-händelser, så att statusservern kan meddelas. Den första kommer att vara för händelsen pull-begäran som skapats och den andra kommer att vara för den uppdaterade händelsen pull-begäran.

För att kunna ta emot aviseringar om tjänstkroken måste du exponera en port för det offentliga Internet. Ngrok-verktyget är mycket användbart för att göra detta i en utvecklingsmiljö.

Ladda ned och packa upp lämplig ngrok-version för din plattform.
Använd ngrok för att börja lyssna på samma port som exempelservern – port 3000. Kör följande kommando i ett nytt kommandofönster.
```
ngrok http 3000
```
Ngrok skapar en offentlig URL som vidarebefordras till localhost:3000. Observera att URL:en som du behöver i nästa steg. Det ser ut ungefär så här:
```
http://c3c1bffa.ngrok.io
```
Bläddra till projektet i Azure DevOps, t.ex. https://dev.azure.com/<your account>/<your project name>
Hovra över kugghjulet på navigeringsmenyn och välj Service Hooks.
Om det här är din första tjänstkrok väljer du + Skapa prenumeration.

Om du redan har konfigurerat andra tjänstkrokar väljer du det gröna plustecknet (+) för att skapa en ny prenumeration på tjänstkroken.
Välj Web Hooks i listan över tjänster i dialogrutan New Service Hooks Subscription (Ny tjänst hooks-prenumeration) och välj sedan Nästa.
Välj Pull-begäran som skapats i listan över händelseutlösare och välj sedan Nästa.
På sidan Åtgärd anger du URL:en från ngrok i rutan URL . Välj Test för att skicka en testhändelse till servern.

I ngrok-konsolfönstret ser du en inkommande POST som returnerade en 200 OK, som anger att servern tog emot service hook-händelsen.
```
HTTP Requests
-------------

POST /                         200 OK
```
I fönstret Testmeddelande väljer du fliken Svar för att se information om svaret från servern. Du bör se en innehållslängd på 17 som matchar längden på strängen från POST-hanteraren (dvs. "Tog emot POST").
Stäng fönstret Testmeddelande och välj Slutför för att skapa tjänstkroken.

Gå igenom steg 3–9 igen, men den här gången konfigurerar du den uppdaterade händelsen pull-begäran.

Viktigt!

Se till att gå igenom föregående steg två gånger och skapa tjänstkrokar för både pull-begäran som skapats och uppdaterade händelser för pull-begäran.

Publicera status till PRs

Nu när servern kan ta emot tjänstkrokhändelser när nya pr-begärandena skapas uppdaterar du den för att publicera bakåtstatus till PR.

Service hook-begäranden innehåller en JSON-nyttolast som beskriver händelsen. Installera body-parser-paketet för att parsa JSON som returneras av tjänstkroken.
```
npm install body-parser
```
Uppdatera app.js för att använda body-parser för parsning application/json.
```
var bodyParser = require('body-parser')

app.use(bodyParser.json())
```
Om du vill förenkla anrop av REST API till Azure Repos installerar du paketet azure-devops-node-api .
```
npm install azure-devops-node-api 
```

Uppdatera app.js för att använda azure-devops-node-api-paketet, konfigurera informationen för en anslutning till ditt konto och hämta en instans av Git-API:et.

const vsts = require("azure-devops-node-api")

const collectionURL = process.env.COLLECTIONURL    
const token = process.env.TOKEN

var authHandler = vsts.getPersonalAccessTokenHandler(token)
var connection = new vsts.WebApi(collectionURL, authHandler)

var vstsGit = connection.getGitApi().then( 
    vstsGit => {                                    
        vstsGit.createPullRequestStatus(prStatus, repoId, pullRequestId).then( result => {
            console.log(result);
        },
        error => {
            console.log(error);
        })
    }, 
    error => { 
        console.log(error);
    } 
);

Skapa en miljövariabel för din samlings-URL och ersätt <your account> med namnet på din Azure DevOps-organisation.
```
setx COLLECTIONURL "https://dev.azure.com/<your account>"
```
Skapa en personlig autentiseringstoken (PAT) för din app att använda, med följande instruktioner: Autentisera med personliga åtkomsttoken. Du bör skapa en ny PAT för varje tjänst som du använder för att komma åt ditt konto och namnge det på rätt sätt.
Skapa en miljövariabel för din PAT.
```
setx TOKEN "yourtokengoeshere"
```
post() Uppdatera funktionen för att läsa PR-informationen från nyttolasten för tjänstkroken. Du behöver dessa värden för att kunna publicera bakåtstatus.
```
var repoId = req.body.resource.repository.id
var pullRequestId = req.body.resource.pullRequestId
var title = req.body.resource.title
```
Skapa statusobjektet som ska postas på PR.

State är en uppräkning av typen GitStatusState. Använd succeeded för att ange att PR:en har klarat statuskontrollen och är redo att slås samman.

description är ett strängvärde som ska visas för användaren i avsnittet Status och aktivitetsfeed i vyn PR-information.

targetUrl är en URL som ska användas för att skapa en länk för beskrivningstexten i avsnittet Status och aktivitetsfeed. Det här är den plats där användarna kan gå för att få mer information om statusen, till exempel en byggrapport eller testkörning. Om ingen URL anges visas beskrivningen som text utan länk.

Kontexten name och genre används för att kategorisera statusen och skilja den från andra tjänsters bokföringsstatus.
```
    var prStatus = {
        "state": "succeeded",
        "description": "Ready for review",
        "targetUrl": "https://visualstudio.microsoft.com",
        "context": {
            "name": "wip-checker",
            "genre": "continuous-integration"
        }
    }
```
I stället för att bara blint publicera statusen succeeded kontrollerar du PR-rubriken för att se om användaren har angett om PR är ett pågående arbete genom att lägga till WIP i rubriken. I så fall ändrar du statusen som bokförts tillbaka till PR.
```
    if (title.includes("WIP")) {
        prStatus.state = "pending"
        prStatus.description = "Work in progress"
    }
```
Publicera slutligen statusen med hjälp av createPullRequestStatus() -metoden. Det kräver statusobjektet, lagringsplatsens ID och pull-begärande-ID. Mata ut svaret till nodkonsolen så att du kan se resultatet av inlägget.
```
vstsGit.createPullRequestStatus(prStatus, repoId, pullRequestId).then( result => {
    console.log(result)
})
```

Den resulterande metoden bör se ut ungefär så här:

app.post("/", function (req, res) {

    // Get the details about the PR from the service hook payload
    var repoId = req.body.resource.repository.id
    var pullRequestId = req.body.resource.pullRequestId
    var title = req.body.resource.title

    // Build the status object that we want to post.
    // Assume that the PR is ready for review...
    var prStatus = {
        "state": "succeeded",
        "description": "Ready for review",
        "targetUrl": "https://visualstudio.microsoft.com",
        "context": {
            "name": "wip-checker",
            "genre": "continuous-integration"
        }
    }

    // Check the title to see if there is "WIP" in the title.
    if (title.includes("WIP")) {

        // If so, change the status to pending and change the description.
        prStatus.state = "pending"
        prStatus.description = "Work in progress"
    }

    // Post the status to the PR
    vstsGit.createPullRequestStatus(prStatus, repoId, pullRequestId).then( result => {
        console.log(result)
    })

    res.send("Received the POST")
})

Spara app.js och starta om nodappen.
```
node app.js
```

Skapa en ny PR för att testa statusservern

Nu när servern körs och lyssnar efter service hook-meddelanden skapar du en pull-begäran för att testa den.

Starta i filvyn. Redigera readme.md filen på lagringsplatsen (eller någon annan fil om du inte har en readme.md).
Gör en redigering och checka in ändringarna på lagringsplatsen.
Se till att checka in ändringarna i en ny gren så att du kan skapa en pr i nästa steg.
Välj länken Skapa en pull-begäran.
Lägg till WIP i rubriken för att testa appens funktioner. Välj Skapa för att skapa PR.
När pr har skapats visas statusavsnittet med posten Arbete pågår som länkar till url:en som anges i nyttolasten.
Uppdatera PR-rubriken och ta bort WIP-texten och observera att statusen ändras från Arbete pågår till Klar för granskning.

Nästa steg

I den här artikeln har du lärt dig grunderna i hur du skapar en tjänst som lyssnar efter PR-händelser via tjänstkrokar och kan publicera statusmeddelanden med hjälp av status-API:et. Mer information om status-API:et för pull-begäran finns i REST API-dokumentationen.
Konfigurera en grenprincip för en extern tjänst.

Dela via