chore(service): add load testing with k6 (#3180)

Author: olevski

load-tests/.gitignore

@@ -0,0 +1 @@
+config.js

load-tests/README.md

@@ -0,0 +1,17 @@
+# Load testing with k6
+
+## To run
+1. Download k6: https://k6.io/docs/get-started/installation/ - you can also get a binary from the github page
+2. Enter the credentials and deployment you wish to test in a file named `config.js`, you can
+use the `example.config.js` to start - just make a copy and rename it.
+3. Run the tests with `k6 run testFileName.js`
+
+## Limitations
+
+- This can log into Renku only and specifically in the cases where Renku has its own built-in gitlab that does
+not require a separate log in OR when the gitlab deployment is part of another renku deployment
+- The login flow cannot handle giving authorization when prompted in the oauth flow - do this
+for the first time manually then run the tests with the same account
+- The project used to test migrations has to be in a namespace that you control and can create
+other projects in. When forks are created they are always created in the same namespace as the
+original project with the name being unique.

load-tests/example.config.js

@@ -0,0 +1,27 @@
+export const baseUrl = "https://dev.renku.ch"
+// oldGitlabProjectId has to point to a project that resides in a namespace that the user
+// has at least maintainer access to. This is because the load tests will fork this project
+// into the same namespace as where the original project resides and only generate a uuid-like
+// name for the project. So if you point to a project that resides in a namespace to which
+// the test runner has no permissions, the forking part of the tests will fail.
+export const oldGitlabProjectId = 5011
+// This project is used to test calling api/renku/project.show, the project is not forked
+// and it does not have the same strict requirements as the project mentioned above. Any
+// public project should work here (whether the user has write access to it or not).
+export const sampleGitProjectUrl = "https://dev.renku.ch/gitlab/tasko.olevski/test-project-2.git"
+
+// Two sets of credentials are needed only if the Renku deployment
+// has a separate Gitlab that requires logging into another Renku
+// instance. So for dev.renku.ch you need one set of credentials
+// for CI deployments you need 2. First the credentials to the
+// CI deployment then the ones for dev.renku.ch.
+export const credentials = [
+  {
+    username: "[email protected]",
+    password: "secret-password1"
+  },
+  {
+    username: "[email protected]",
+    password: "secret-password1"
+  },
+]

load-tests/fileUpload.js

@@ -0,0 +1,84 @@
+// Creator: k6 Browser Recorder 0.6.2
+
+import { sleep, check, fail } from 'k6'
+import http from 'k6/http'
+import { uuidv4 } from 'https://jslib.k6.io/k6-utils/1.2.0/index.js';
+import crypto from 'k6/crypto';
+import { URL } from 'https://jslib.k6.io/url/1.0.0/index.js';
+
+import { renkuLogin } from './oauth.js'
+import { credentials, baseUrl } from './config.js'
+
+export const options = {
+  scenarios: {
+    testUploads: {
+      executor: 'per-vu-iterations',
+      vus: 3,
+      iterations: 1,
+    },
+  }
+}
+
+function uploadRandomFile(baseUrl, uuid, fileName, numChunks, chunkSizeBytes) {
+  const responses = []
+  for (let i = 0; i < numChunks; i++) {
+    const url = new URL(`ui-server/api/renku/cache.files_upload`, baseUrl);
+    url.searchParams.append('dzuuid', uuid);
+    url.searchParams.append('dzchunkindex', i);
+    url.searchParams.append('dztotalfilesize', numChunks * chunkSizeBytes);
+    url.searchParams.append('dzchunksize', chunkSizeBytes);
+    url.searchParams.append('dztotalchunkcount', numChunks);
+    url.searchParams.append('dzchunkbyteoffset', i * chunkSizeBytes);
+    url.searchParams.append('chunked_content_type', "application/octet-stream");
+    const res = http.post(url.toString(), {
+      file: http.file(crypto.randomBytes(chunkSizeBytes), fileName, "application/octet-stream")
+    })
+    responses.push(res)
+  }
+  if (!check(responses, {
+    "file uploads all have 200 repsonses": (responses) => responses.every(res => res.status === 200),
+    "file uploads all completed without errors": (responses) => responses.every(res => res.json().error === undefined),
+  })) {
+    const errResponses = responses.filter(res => res.json().error !== undefined).map(res => res.json())
+    const failedResponsesBody = responses.filter(res => res.status != 200).map(res => res.body)
+    const failedResponsesCodes = responses.filter(res => res.status != 200).map(res => res.status)
+    fail(
+      `some responses failed with errors ${JSON.stringify(errResponses)}\nsome respones ` +
+      `failed with non-200 status codes codes: ${JSON.stringify(failedResponsesCodes)} bodies: ${JSON.stringify(failedResponsesBody)}`
+    )
+  };
+  return responses[numChunks - 1]
+}
+
+export default function fileUpload() {
+  renkuLogin(baseUrl, credentials)
+  const baseUrlResponse = http.get(baseUrl)
+  const projects = http.get(`${baseUrl}/ui-server/api/projects?query=last_activity_at&per_page=100&starred=true&page=1`)
+  check(baseUrlResponse, {
+    "baseUrl responds with status 200": (r) => r.status === 200,
+  });
+  check(projects, {
+    'projects list endpoint responds with status 200': (r) => r.status === 200,
+    'project list exists': (r) => r.json().length >= 0,
+  });
+  sleep(1)
+  const uploads = http.get(`${baseUrl}/ui-server/api/renku/cache.files_list`)
+  check(uploads, {
+    'uploads list response does not have errors': (r) => r.json().error === undefined,
+    'uploads list response contains a list of uploads': (r) => r.json().result.files.length >= 0,
+  });
+  sleep(1)
+  const uuid = uuidv4()
+  const fileName = `${uuid}.bin`
+  const fileUploadResponse = uploadRandomFile(baseUrl, uuid, fileName, 100, 1e6)
+  let uploadedFiles = fileUploadResponse.json().result.files
+  if (uploadedFiles === undefined) {
+    uploadedFiles = []
+  }
+  uploadedFiles = uploadedFiles.map(i => i.file_name)
+  if (!check(uploadedFiles, {
+    'file name found in last upload response': (r) => r.includes(fileName),
+  })) {
+    fail(`could not find file in last upload response, body: ${fileUploadResponse.body}, status code: ${fileUploadResponse.status}`)
+  }
+}

load-tests/oauth.js

@@ -0,0 +1,54 @@
+import http from 'k6/http';
+import { parseHTML } from 'k6/html';
+
+function handleRenkuLoginForm(httpResponse, username, password) {
+  const doc = parseHTML(httpResponse.body);
+  const actionUrl = doc.find('#kc-form-login').attr('action');
+  if (!actionUrl) {
+    throw new Error(`Could not locate login form in http response ${httpResponse.body}`)
+  }
+  const loginData = {
+    username,
+    password,
+    credentialId: '',
+  };
+  return http.post(actionUrl, loginData)
+}
+
+function followRedirectLinkFromHtml(httpResponse) {
+  const doc = parseHTML(httpResponse.body);
+  let url = doc.find('a').attr("href")
+  if (!url) {
+    throw new Error(`Could not find <a> element with href attribute in ${httpResponse.body}`)
+  }
+  if (url.endsWith("/")) {
+    // leaving trailing slashes here results in 404
+    url = url.slice(0,-1)
+  }
+  return http.get(url)
+}
+
+export function renkuLogin(baseUrl, credentials) {
+  // double slashes when composing url causes trouble and 404s
+  if (baseUrl.endsWith("/")) {
+    baseUrl = baseUrl.slice(0,-1)
+  }
+  // the trailing slash is needed here keycloak accepts only such and longer callbacks
+  const redirectUrl = `${baseUrl}/`
+  let finalResponse = null
+  const res1 = http.get(`${baseUrl}/ui-server/auth/login?redirect_url=${redirectUrl}"`)
+  const res2 = handleRenkuLoginForm(res1, credentials[0].username, credentials[0].password)
+  const res3 = followRedirectLinkFromHtml(res2)
+  if (res3.body.match(".*redirect.*|.*Redirect.*") && parseHTML(res3.body).find("a").toArray().length > 0) {
+    // no more login forms just follow a single last redirect
+    finalResponse = followRedirectLinkFromHtml(res3)
+  }
+  else if (parseHTML(res3.body).find('#kc-form-login').toArray().length > 0) {
+    // one more login required, usually happens for ci and similar deployments that do not have their own gitlab
+    const res4 = handleRenkuLoginForm(res3, credentials[1].username, credentials[1].password)
+    finalResponse = followRedirectLinkFromHtml(res4)
+  }
+  if (finalResponse.status != 200) {
+    throw new Error(`Could not successfully login, expected status code 200 but got ${finalResponse.status}`)
+  }
+}

load-tests/parallelRequests.js

@@ -0,0 +1,55 @@
+import http from 'k6/http';
+import { check, fail, sleep } from 'k6';
+
+import { renkuLogin } from './oauth.js'
+import { credentials, baseUrl, sampleGitProjectUrl } from './config.js'
+
+export const options = {
+  scenarios: {
+    testUploads: {
+      executor: 'per-vu-iterations',
+      vus: 3,
+      iterations: 1,
+    },
+  }
+}
+
+function getTemplates(baseUrl, templatesRef) {
+  const res = http.get(`${baseUrl}/ui-server/api/renku/templates.read_manifest?url=https%3A%2F%2Fgithub.com%2FSwissDataScienceCenter%2Frenku-project-template&ref=${templatesRef}`)
+  if (!check(res, {
+    "reading templates succeeded with 2XX": (res) => res.status >= 200 && res.status < 300,
+    "reading templates response has no error": (res) => res.json().error === undefined,
+    "reading templates response more than zero templates": (res) => res.json().result.templates.length > 0,
+  })) {
+    fail(`reading templates failed with status code ${res.status} and response ${res.body}`)
+  }
+  return res
+}
+
+function showProjectInfo(baseUrl, gitUrl) {
+  const payload = {
+    git_url: gitUrl,
+    is_delayed: false,
+    migrate_project: false
+  }
+  const res = http.post(
+    `${baseUrl}/ui-server/api/renku/project.show`,
+    JSON.stringify(payload),
+    { headers: { "Content-Type": "application/json" } },
+  )
+  if (!check(res, {
+    "getting project info succeeded with 2XX": (res) => res.status >= 200 && res.status < 300,
+    "getting project info response has no error": (res) => res.json().error === undefined,
+  })) {
+    fail(`getting project info failed with status ${res.status} and body ${res.body}`)
+  }
+  return res
+}
+
+export default function test() {
+  renkuLogin(baseUrl, credentials)
+  const templatesRef = "0.3.4"
+  getTemplates(baseUrl, templatesRef)
+  sleep(2)
+  showProjectInfo(baseUrl, sampleGitProjectUrl)
+}

load-tests/projectMigration.js

@@ -0,0 +1,87 @@
+import http from 'k6/http';
+import { check, fail, sleep } from 'k6';
+import { uuidv4 } from 'https://jslib.k6.io/k6-utils/1.2.0/index.js';
+
+import { renkuLogin } from './oauth.js'
+import { credentials, baseUrl, oldGitlabProjectId } from './config.js'
+
+export const options = {
+  scenarios: {
+    testUploads: {
+      executor: 'per-vu-iterations',
+      vus: 3,
+      iterations: 1,
+    },
+  }
+}
+
+function forkProject(baseUrl, gitlabProjectId) {
+  const uuid = uuidv4()
+  let projectData = http.get(`${baseUrl}/ui-server/api/projects/${gitlabProjectId}`)
+  check( projectData, {
+    "response code for getting project info was 2XX": (res) => res.status >= 200 && res.status < 300,
+  })
+  projectData = projectData.json()
+  let forkName = `test-forked-project-${uuid}`
+  const payload = {
+    id: gitlabProjectId,
+    name: forkName,
+    namespace_id: projectData.namespace.id,
+    path: forkName,
+    visibility: projectData.visibility,
+  }
+  let forkRes = http.post(`${baseUrl}/ui-server/api/projects/${gitlabProjectId}/fork`, payload)
+  if (!check( forkRes, {
+    "response code for forking was 2XX": (res) => res.status >= 200 && res.status < 300,
+  })) {
+    fail(`forking failed with code ${forkRes.status} and body ${forkRes.body}`)
+  }
+  sleep(5)
+  return forkRes
+}
+
+function migrateProject(baseUrl, gitlabProjectId) {
+  let projectData = http.get(`${baseUrl}/ui-server/api/projects/${gitlabProjectId}`)
+  check( projectData, {
+    "response code for getting project info is 2XX": (res) => res.status >= 200 && res.status < 300,
+  })
+  projectData = projectData.json()
+  const migratePayload = {
+    branch: projectData.default_branch,
+    force_template_update: true,
+    git_url: projectData.http_url_to_repo,
+    is_delayed: false,
+    skip_docker_update: false,
+    skip_migrations: false,
+    skip_template_update: false,
+  }
+  const migrateRes = http.post(
+    `${baseUrl}/ui-server/api/renku/cache.migrate`,
+    JSON.stringify(migratePayload), {headers: {"Content-Type": "application/json"}}
+  )
+  if (!check( migrateRes, {
+    "response code for migrating is 2XX": (res) => res.status >= 200 && res.status < 300,
+  })) {
+    fail(`migration completed with code ${migrateRes.status}`)
+  }
+  if (!check( migrateRes, {
+    "migration request has no errors": (res) => res.json().error === undefined,
+  })) {
+    fail(`migration completed with errors: ${JSON.stringify(migrateRes.json().error)}`)
+  }
+  check( migrateRes, {
+    "was_migrated is true in migration response": (res) => res.json().result.was_migrated,
+  })
+  return migrateRes
+}
+
+export default function test() {
+  renkuLogin(baseUrl, credentials)
+  const forkedProjectResponse = forkProject(baseUrl, oldGitlabProjectId)
+  const forkProjectId = forkedProjectResponse.json().id
+  migrateProject(baseUrl, forkProjectId)
+  const res = http.del(`${baseUrl}/ui-server/api/projects/${forkProjectId}`)
+  check( res, {
+    "deletion of fork succeeded with 2XX": (res) => res.status >= 200 && res.status < 300,
+  })
+}