BitbucketVcsAccessProvider.kt
/*
Copyright (C) 2026 Sber
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
In any derivative products, you must retain the information of
owner of the original code and provide clear attribution to the project
https://dochub.info
The use of this product or its derivatives for any purpose cannot be a secret.
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.
Maintainers:
Alexander Romashin <romashin.a.va@sberbank.ru>, Sber - 2025
Contributors:
Alexander Romashin <romashin.a.va@sberbank.ru>, Sber - 2025
Alexander Romashin <romashin.a.va@sberbank.ru>, Sber - 2026
Марат Ниязматов <mrusniyazmatov@sberbank.ru>, Sber - 2026
*/
package org.archtool.vcs.provider.bitbucket
import io.ktor.client.HttpClient
import io.ktor.client.call.body
import io.ktor.client.plugins.auth.Auth
import io.ktor.client.plugins.auth.providers.BearerTokens
import io.ktor.client.plugins.auth.providers.bearer
import io.ktor.client.request.get
import io.ktor.client.request.parameter
import io.ktor.http.HttpHeaders
import io.ktor.http.HttpStatusCode
import io.ktor.http.URLBuilder
import io.ktor.http.appendPathSegments
import kotlinx.coroutines.CancellationException
import org.archtool.vcs.provider.bitbucket.dto.DefaultPermissionDto
import org.archtool.vcs.provider.bitbucket.dto.PageDto
import org.archtool.vcs.provider.bitbucket.dto.ProjectPermission
import org.archtool.vcs.provider.bitbucket.dto.RepoInfoDto
import org.archtool.vcs.provider.bitbucket.dto.RepoPermission
import org.archtool.vcs.provider.bitbucket.dto.UserProjectPermissionDto
import org.archtool.vcs.provider.bitbucket.dto.UserRepoPermissionDto
import org.archtool.data.model.RepoInfoModel
import org.archtool.data.model.SeafPermission
import org.archtool.helper.VcsHttpClientFactory
import org.archtool.vcs.provider.SyncedRepositories
import org.archtool.vcs.provider.VcsAccessProvider
import org.archtool.vcs.provider.VcsApiException
import org.archtool.vcs.provider.VcsApiUtils
import org.archtool.vcs.provider.VcsProjectKey
import org.archtool.vcs.provider.VcsProviderType
import org.archtool.vcs.provider.VcsRepoSlug
import org.archtool.vcs.provider.VcsUser
import org.archtool.service.RepoService
import org.archtool.service.UserService
import org.slf4j.Logger
import org.slf4j.LoggerFactory
import org.springframework.stereotype.Component
import java.time.Instant
@Component
@ConditionalOnBitbucket
class BitbucketVcsAccessProvider(
private val properties: BitbucketProperties,
private val vcsHttpClientFactory: VcsHttpClientFactory,
private val repoService: RepoService,
private val userService: UserService,
) : VcsAccessProvider {
private val httpClient: HttpClient = vcsHttpClientFactory.createClient(HttpHeaders.Authorization) {
install(Auth) {
bearer {
loadTokens {
BearerTokens(properties.token, null)
}
}
}
}
init {
if (properties.normalizedProjectKeys.isEmpty()) {
log.info("Фильтр по проектам Bitbucket не задан, загружаются все доступные репозитории")
} else {
log.info(
"Фильтр по проектам Bitbucket; исходное значение: {}, после нормализации: {}",
properties.projectKeys,
properties.normalizedProjectKeys,
)
}
}
override suspend fun syncRepositories(sequence: Long, expirationTime: Instant): SyncedRepositories {
log.debug("=== Запрашиваем и обновляем репозитории Bitbucket ===")
val repoProjectsMap: MutableMap<VcsProjectKey, MutableSet<VcsRepoSlug>> = mutableMapOf()
val defaultPermissionsByProject: MutableMap<String, SeafPermission?> = mutableMapOf()
val projectKeys = properties.normalizedProjectKeys
if (projectKeys.isEmpty()) {
syncRepos(null, sequence, expirationTime, repoProjectsMap, defaultPermissionsByProject)
} else {
for (projectKey in projectKeys) {
syncRepos(projectKey, sequence, expirationTime, repoProjectsMap, defaultPermissionsByProject)
if (repoProjectsMap.keys.none { it.equals(projectKey, ignoreCase = true) }) {
log.warn("Проект Bitbucket {} из фильтра не вернул ни одного репозитория", projectKey)
}
}
}
return SyncedRepositories(repoProjectsMap)
}
/**
* Загружает репозитории с правом `REPO_READ`; при заданном [projectKey] — только репозитории этого проекта.
*/
private suspend fun syncRepos(
projectKey: String?,
sequence: Long,
expirationTime: Instant,
repoProjectsMap: MutableMap<VcsProjectKey, MutableSet<VcsRepoSlug>>,
defaultPermissionsByProject: MutableMap<String, SeafPermission?>,
) {
val url = properties.reposUrl
forAllPages { start ->
log.debug(
"Запрос репозиториев {}, проект {}, start {}, limit {}",
url,
projectKey,
start,
properties.pageSize,
)
val page = vcsHttpClientFactory.execute(httpClient) { client ->
val response = client.get(url) {
parameter("start", start)
parameter("limit", properties.pageSize)
parameter("permission", RepoPermission.REPO_READ)
projectKey?.let { parameter(PROJECT_KEY_PARAMETER, it) }
}
VcsApiUtils.requireSuccess(response, VcsProviderType.BITBUCKET, url)
response.body() as PageDto<RepoInfoDto>
}
for (repo in page.values.filter { belongsToProject(it, projectKey) }) {
log.debug("Обрабатываем репозиторий {} в проекте {}", repo.slug, repo.project.key)
try {
repoProjectsMap.getOrPut(repo.project.key) { mutableSetOf() }.add(repo.slug)
val cloneLink = repo.links["clone"]?.find { it.name == "http" }?.href ?: ""
val webLink = repo.links["self"]?.get(0)?.href ?: ""
val defaultPermission = defaultPermissionsByProject.getOrPut(repo.project.key) {
getDefaultPermissionForProject(repo.project.key)
}
repoService.saveRepo(
repoInfo = RepoInfoModel(
slug = repo.slug,
projectKey = repo.project.key,
name = repo.name,
description = repo.description,
cloneLink = cloneLink,
webLink = webLink,
defaultPermission = defaultPermission,
),
sequence = sequence,
expirationTime = expirationTime,
)
} catch (e: CancellationException) {
throw e
} catch (e: VcsApiException) {
if (e.status == HttpStatusCode.Unauthorized) {
throw e
}
log.error(
"Ошибка при обновлении репозитория ${repo.slug} в проекте ${repo.project.key}",
e,
)
} catch (e: Exception) {
log.error(
"Ошибка при обновлении репозитория ${repo.slug} в проекте ${repo.project.key}",
e,
)
}
}
page
}
}
override suspend fun syncUsers(
repositories: SyncedRepositories,
sequence: Long,
expirationTime: Instant,
) {
log.debug("=== Запрашиваем пользователей и права на репозитории Bitbucket ===")
for ((projectKey, repoSlugs) in repositories.slugsByProjectKey) {
log.debug("Запрашиваем права на проект {}", projectKey)
val projectPermissionsUrl = projectUrl(projectKey, "permissions", "users")
forAllPages { start ->
val page = vcsHttpClientFactory.execute(httpClient) { client ->
val response = client.get(projectPermissionsUrl) {
parameter("start", start)
parameter("limit", properties.pageSize)
}
VcsApiUtils.requireSuccess(response, VcsProviderType.BITBUCKET, projectPermissionsUrl)
response.body() as PageDto<UserProjectPermissionDto>
}
log.trace("Получили из бб {} пользователей", page.size)
for (userPermission in page.values) {
if (!userPermission.user.active) {
log.trace(
"[{}] Пользователь проекта не активен, права не получены",
userPermission.user.name,
)
continue
}
userService.insertUserIfNotExistsAndSaveRepoRelations(
VcsUser(externalId = userPermission.user.name),
repoSlugs,
projectKey,
sequence,
expirationTime,
mapProjectPermission(userPermission.permission),
)
}
page
}
log.debug("Запрашиваем права на репозитории проекта {}", projectKey)
for (repoSlug in repoSlugs) {
log.debug("[projectKey={}] Запрашиваем права на репозиторий {}", projectKey, repoSlug)
val repoPermissionsUrl = projectUrl(projectKey, "repos", repoSlug, "permissions", "users")
forAllPages { start ->
val page = vcsHttpClientFactory.execute(httpClient) { client ->
val response = client.get(repoPermissionsUrl) {
parameter("start", start)
parameter("limit", properties.pageSize)
}
VcsApiUtils.requireSuccess(response, VcsProviderType.BITBUCKET, repoPermissionsUrl)
response.body() as PageDto<UserRepoPermissionDto>
}
for (userPermission in page.values) {
if (!userPermission.user.active) {
log.trace(
"[{}] Пользователь репозитория не активен, права не получены",
userPermission.user.name,
)
continue
}
userService.insertUserIfNotExistsAndSaveRepoRelations(
VcsUser(externalId = userPermission.user.name),
setOf(repoSlug),
projectKey,
sequence,
expirationTime,
mapRepoPermission(userPermission.permission),
)
}
page
}
}
}
}
// Страховка на случай, когда Bitbucket игнорирует параметр projectkey (версия ниже 8.0 при отключённой
// проверке версии или ошибка Bitbucket) и возвращает репозитории других проектов.
private fun belongsToProject(repo: RepoInfoDto, projectKey: String?): Boolean {
if (projectKey == null || repo.project.key.equals(projectKey, ignoreCase = true)) {
return true
}
log.warn(
"Репозиторий {} проекта {} пропущен: не соответствует запрошенному проекту {}",
repo.slug,
repo.project.key,
projectKey,
)
return false
}
private suspend fun getDefaultPermissionForProject(projectKey: String): SeafPermission? =
when {
isDefaultPermissionGranted(projectKey, ProjectPermission.PROJECT_ADMIN) -> SeafPermission.WRITE
isDefaultPermissionGranted(projectKey, ProjectPermission.REPO_CREATE) -> SeafPermission.WRITE
isDefaultPermissionGranted(projectKey, ProjectPermission.PROJECT_WRITE) -> SeafPermission.WRITE
isDefaultPermissionGranted(projectKey, ProjectPermission.PROJECT_READ) -> SeafPermission.READ
else -> null
}
private suspend fun isDefaultPermissionGranted(projectKey: String, permission: ProjectPermission): Boolean {
val url = projectUrl(projectKey, "permissions", permission.name, "all")
return vcsHttpClientFactory.execute(httpClient) { client ->
val response = client.get(url)
VcsApiUtils.requireSuccess(response, VcsProviderType.BITBUCKET, url)
(response.body() as DefaultPermissionDto).permitted
}
}
private fun projectUrl(projectKey: String, vararg pathSegments: String): String =
URLBuilder(properties.projectsUrl)
.appendPathSegments(projectKey, *pathSegments)
.buildString()
private suspend inline fun <reified T> forAllPages(block: suspend (start: Int) -> PageDto<T>) {
var start = 0
do {
val page = block(start)
start = page.start + page.limit
} while (!page.isLastPage)
}
private fun mapProjectPermission(permission: ProjectPermission): SeafPermission =
when (permission) {
ProjectPermission.PROJECT_ADMIN -> SeafPermission.WRITE
ProjectPermission.REPO_CREATE -> SeafPermission.WRITE
ProjectPermission.PROJECT_WRITE -> SeafPermission.WRITE
ProjectPermission.PROJECT_READ -> SeafPermission.READ
}
private fun mapRepoPermission(permission: RepoPermission): SeafPermission =
when (permission) {
RepoPermission.REPO_ADMIN -> SeafPermission.WRITE
RepoPermission.REPO_WRITE -> SeafPermission.WRITE
RepoPermission.REPO_READ -> SeafPermission.READ
}
companion object {
private const val PROJECT_KEY_PARAMETER = "projectkey"
private val log: Logger = LoggerFactory.getLogger(BitbucketVcsAccessProvider::class.java)
}
}