Added tag v4.14.1 for changeset a47eeac5dfa4
Added tag v4.14.1 for changeset a47eeac5dfa4

File last commit:

r3104:4de59e0f default
r3205:fd4b2bf5 stable
Show More
repo_api.py
2065 lines | 69.6 KiB | text/x-python | PythonLexer
project: added all source files and assets
r1 # -*- coding: utf-8 -*-
release: update copyright year to 2018
r2487 # Copyright (C) 2011-2018 RhodeCode GmbH
project: added all source files and assets
r1 #
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License, version 3
# (only), as published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
# This program is dual-licensed. If you wish to learn more about the
# RhodeCode Enterprise Edition, including its added features, Support services,
# and proprietary license terms, please see https://rhodecode.com/licenses/
import logging
import time
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 import rhodecode
from rhodecode.api import (
jsonrpc_method, JSONRPCError, JSONRPCForbidden, JSONRPCValidationError)
project: added all source files and assets
r1 from rhodecode.api.utils import (
has_superadmin_permission, Optional, OAttr, get_repo_or_error,
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 get_user_group_or_error, get_user_or_error, validate_repo_permissions,
get_perm_or_error, parse_args, get_origin, build_commit_data,
validate_set_owner_permissions)
audit-logger: unify calls to repo.delete and also store source of call, api/web.
r1752 from rhodecode.lib import audit_logger
api: added maintenance command into API.
r1742 from rhodecode.lib import repo_maintenance
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 from rhodecode.lib.auth import HasPermissionAnyApi, HasUserGroupPermissionAnyApi
celery: celery 4.X support. Fixes #4169...
r2359 from rhodecode.lib.celerylib.utils import get_task_id
exceptions: use python3 compatible exception handling
r3104 from rhodecode.lib.utils2 import str2bool, time_to_datetime, safe_str
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 from rhodecode.lib.ext_json import json
api: validate commit_id when using commit_comment API
r1416 from rhodecode.lib.exceptions import StatusChangeOnClosedPullRequestError
project: added all source files and assets
r1 from rhodecode.model.changeset_status import ChangesetStatusModel
comments: renamed ChangesetCommentsModel to CommentsModel to reflect what it actually does....
r1323 from rhodecode.model.comment import CommentsModel
project: added all source files and assets
r1 from rhodecode.model.db import (
api: added possibility to specify comment_type for comment API.
r1337 Session, ChangesetStatus, RepositoryField, Repository, RepoGroup,
ChangesetComment)
project: added all source files and assets
r1 from rhodecode.model.repo import RepoModel
from rhodecode.model.scm import ScmModel, RepoList
Martin Bornhold
api: Add api methods to get/set repository settings, implements #4021
r387 from rhodecode.model.settings import SettingsModel, VcsSettingsModel
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 from rhodecode.model import validation_schema
gists: use colander schema to validate input data....
r523 from rhodecode.model.validation_schema.schemas import repo_schema
project: added all source files and assets
r1
log = logging.getLogger(__name__)
@jsonrpc_method()
def get_repo(request, apiuser, repoid, cache=Optional(True)):
"""
Gets an existing repository by its name or repository_id.
The members section so the output returns users groups or users
associated with that repository.
This command can only be run using an |authtoken| with admin rights,
or users with at least read rights to the |repo|.
:param apiuser: This is filled automatically from the |authtoken|.
:type apiuser: AuthUser
:param repoid: The repository name or repository id.
:type repoid: str or int
:param cache: use the cached value for last changeset
:type: cache: Optional(bool)
Example output:
.. code-block:: bash
{
"error": null,
"id": <repo_id>,
"result": {
"clone_uri": null,
"created_on": "timestamp",
"description": "repo description",
"enable_downloads": false,
"enable_locking": false,
"enable_statistics": false,
"followers": [
{
"active": true,
"admin": false,
"api_key": "****************************************",
"api_keys": [
"****************************************"
],
"email": "user@example.com",
"emails": [
"user@example.com"
],
"extern_name": "rhodecode",
"extern_type": "rhodecode",
"firstname": "username",
"ip_addresses": [],
"language": null,
"last_login": "2015-09-16T17:16:35.854",
"lastname": "surname",
"user_id": <user_id>,
"username": "name"
}
],
"fork_of": "parent-repo",
"landing_rev": [
"rev",
"tip"
],
"last_changeset": {
"author": "User <user@example.com>",
"branch": "default",
"date": "timestamp",
"message": "last commit message",
"parents": [
{
"raw_id": "commit-id"
}
],
"raw_id": "commit-id",
"revision": <revision number>,
"short_id": "short id"
},
"lock_reason": null,
"locked_by": null,
"locked_date": null,
"owner": "owner-name",
"permissions": [
{
"name": "super-admin-name",
"origin": "super-admin",
"permission": "repository.admin",
"type": "user"
},
{
"name": "owner-name",
"origin": "owner",
"permission": "repository.admin",
"type": "user"
},
{
"name": "user-group-name",
"origin": "permission",
"permission": "repository.write",
"type": "user_group"
}
],
"private": true,
"repo_id": 676,
"repo_name": "user-group/repo-name",
"repo_type": "hg"
}
}
"""
repo = get_repo_or_error(repoid)
cache = Optional.extract(cache)
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153
project: added all source files and assets
r1 include_secrets = False
if has_superadmin_permission(apiuser):
include_secrets = True
else:
# check if we have at least read permission for this repo !
_perms = (
'repository.admin', 'repository.write', 'repository.read',)
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 validate_repo_permissions(apiuser, repoid, repo, _perms)
project: added all source files and assets
r1
permissions = []
for _user in repo.permissions():
user_data = {
'name': _user.username,
'permission': _user.permission,
'origin': get_origin(_user),
'type': "user",
}
permissions.append(user_data)
for _user_group in repo.permission_user_groups():
user_group_data = {
'name': _user_group.users_group_name,
'permission': _user_group.permission,
'origin': get_origin(_user_group),
'type': "user_group",
}
permissions.append(user_group_data)
following_users = [
user.user.get_api_data(include_secrets=include_secrets)
for user in repo.followers]
if not cache:
repo.update_commit_cache()
data = repo.get_api_data(include_secrets=include_secrets)
data['permissions'] = permissions
data['followers'] = following_users
return data
@jsonrpc_method()
api: get_repos allows now to filter by root locations, and optionally traverse the returned data....
r1267 def get_repos(request, apiuser, root=Optional(None), traverse=Optional(True)):
project: added all source files and assets
r1 """
Lists all existing repositories.
This command can only be run using an |authtoken| with admin rights,
or users with at least read rights to |repos|.
:param apiuser: This is filled automatically from the |authtoken|.
:type apiuser: AuthUser
api: get_repos allows now to filter by root locations, and optionally traverse the returned data....
r1267 :param root: specify root repository group to fetch repositories.
filters the returned repositories to be members of given root group.
:type root: Optional(None)
:param traverse: traverse given root into subrepositories. With this flag
set to False, it will only return top-level repositories from `root`.
if root is empty it will return just top-level repositories.
:type traverse: Optional(True)
project: added all source files and assets
r1
Example output:
.. code-block:: bash
id : <id_given_in_input>
result: [
{
"repo_id" : "<repo_id>",
"repo_name" : "<reponame>"
"repo_type" : "<repo_type>",
"clone_uri" : "<clone_uri>",
"private": : "<bool>",
"created_on" : "<datetimecreated>",
"description" : "<description>",
"landing_rev": "<landing_rev>",
"owner": "<repo_owner>",
"fork_of": "<name_of_fork_parent>",
"enable_downloads": "<bool>",
"enable_locking": "<bool>",
"enable_statistics": "<bool>",
},
...
]
error: null
"""
include_secrets = has_superadmin_permission(apiuser)
_perms = ('repository.read', 'repository.write', 'repository.admin',)
extras = {'user': apiuser}
api: get_repos allows now to filter by root locations, and optionally traverse the returned data....
r1267 root = Optional.extract(root)
traverse = Optional.extract(traverse, binary=True)
if root:
# verify parent existance, if it's empty return an error
parent = RepoGroup.get_by_group_name(root)
if not parent:
raise JSONRPCError(
'Root repository group `{}` does not exist'.format(root))
if traverse:
repos = RepoModel().get_repos_for_root(root=root, traverse=traverse)
else:
repos = RepoModel().get_repos_for_root(root=parent)
else:
if traverse:
repos = RepoModel().get_all()
else:
# return just top-level
repos = RepoModel().get_repos_for_root(root=None)
repo_list = RepoList(repos, perm_set=_perms, extra_kwargs=extras)
project: added all source files and assets
r1 return [repo.get_api_data(include_secrets=include_secrets)
for repo in repo_list]
@jsonrpc_method()
def get_repo_changeset(request, apiuser, repoid, revision,
details=Optional('basic')):
"""
Returns information about a changeset.
Additionally parameters define the amount of details returned by
this function.
This command can only be run using an |authtoken| with admin rights,
or users with at least read rights to the |repo|.
:param apiuser: This is filled automatically from the |authtoken|.
:type apiuser: AuthUser
:param repoid: The repository name or repository id
:type repoid: str or int
:param revision: revision for which listing should be done
:type revision: str
:param details: details can be 'basic|extended|full' full gives diff
info details like the diff itself, and number of changed files etc.
:type details: Optional(str)
"""
repo = get_repo_or_error(repoid)
if not has_superadmin_permission(apiuser):
_perms = (
'repository.admin', 'repository.write', 'repository.read',)
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 validate_repo_permissions(apiuser, repoid, repo, _perms)
project: added all source files and assets
r1
changes_details = Optional.extract(details)
_changes_details_types = ['basic', 'extended', 'full']
if changes_details not in _changes_details_types:
raise JSONRPCError(
'ret_type must be one of %s' % (
','.join(_changes_details_types)))
pre_load = ['author', 'branch', 'date', 'message', 'parents',
'status', '_commit', '_file_paths']
try:
cs = repo.get_commit(commit_id=revision, pre_load=pre_load)
except TypeError as e:
exceptions: use python3 compatible exception handling
r3104 raise JSONRPCError(safe_str(e))
project: added all source files and assets
r1 _cs_json = cs.__json__()
_cs_json['diff'] = build_commit_data(cs, changes_details)
if changes_details == 'full':
vcs: commits, expose refs function to fetch commit refereces such as tags, bookmarks, etc.
r2337 _cs_json['refs'] = cs._get_refs()
project: added all source files and assets
r1 return _cs_json
@jsonrpc_method()
def get_repo_changesets(request, apiuser, repoid, start_rev, limit,
details=Optional('basic')):
"""
api: gracefully handle errors on repos that are damaged or missing from filesystem.
r61 Returns a set of commits limited by the number starting
project: added all source files and assets
r1 from the `start_rev` option.
Additional parameters define the amount of details returned by this
function.
This command can only be run using an |authtoken| with admin rights,
or users with at least read rights to |repos|.
:param apiuser: This is filled automatically from the |authtoken|.
:type apiuser: AuthUser
:param repoid: The repository name or repository ID.
:type repoid: str or int
:param start_rev: The starting revision from where to get changesets.
:type start_rev: str
api: gracefully handle errors on repos that are damaged or missing from filesystem.
r61 :param limit: Limit the number of commits to this amount
project: added all source files and assets
r1 :type limit: str or int
:param details: Set the level of detail returned. Valid option are:
``basic``, ``extended`` and ``full``.
:type details: Optional(str)
.. note::
Setting the parameter `details` to the value ``full`` is extensive
and returns details like the diff itself, and the number
of changed files.
"""
repo = get_repo_or_error(repoid)
if not has_superadmin_permission(apiuser):
_perms = (
'repository.admin', 'repository.write', 'repository.read',)
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 validate_repo_permissions(apiuser, repoid, repo, _perms)
project: added all source files and assets
r1
changes_details = Optional.extract(details)
_changes_details_types = ['basic', 'extended', 'full']
if changes_details not in _changes_details_types:
raise JSONRPCError(
'ret_type must be one of %s' % (
','.join(_changes_details_types)))
limit = int(limit)
pre_load = ['author', 'branch', 'date', 'message', 'parents',
'status', '_commit', '_file_paths']
vcs_repo = repo.scm_instance()
# SVN needs a special case to distinguish its index and commit id
api: gracefully handle errors on repos that are damaged or missing from filesystem.
r61 if vcs_repo and vcs_repo.alias == 'svn' and (start_rev == '0'):
project: added all source files and assets
r1 start_rev = vcs_repo.commit_ids[0]
try:
api: gracefully handle errors on repos that are damaged or missing from filesystem.
r61 commits = vcs_repo.get_commits(
project: added all source files and assets
r1 start_id=start_rev, pre_load=pre_load)
except TypeError as e:
exceptions: use python3 compatible exception handling
r3104 raise JSONRPCError(safe_str(e))
api: gracefully handle errors on repos that are damaged or missing from filesystem.
r61 except Exception:
log.exception('Fetching of commits failed')
raise JSONRPCError('Error occurred during commit fetching')
project: added all source files and assets
r1
ret = []
for cnt, commit in enumerate(commits):
if cnt >= limit != -1:
break
_cs_json = commit.__json__()
_cs_json['diff'] = build_commit_data(commit, changes_details)
if changes_details == 'full':
_cs_json['refs'] = {
'branches': [commit.branch],
'bookmarks': getattr(commit, 'bookmarks', []),
'tags': commit.tags
}
ret.append(_cs_json)
return ret
@jsonrpc_method()
def get_repo_nodes(request, apiuser, repoid, revision, root_path,
dan
api: add a max_file_bytes parameter to get_nodes so that large...
r502 ret_type=Optional('all'), details=Optional('basic'),
max_file_bytes=Optional(None)):
project: added all source files and assets
r1 """
Returns a list of nodes and children in a flat list for a given
path at given revision.
It's possible to specify ret_type to show only `files` or `dirs`.
This command can only be run using an |authtoken| with admin rights,
or users with at least read rights to |repos|.
:param apiuser: This is filled automatically from the |authtoken|.
:type apiuser: AuthUser
:param repoid: The repository name or repository ID.
:type repoid: str or int
:param revision: The revision for which listing should be done.
:type revision: str
:param root_path: The path from which to start displaying.
:type root_path: str
:param ret_type: Set the return type. Valid options are
``all`` (default), ``files`` and ``dirs``.
:type ret_type: Optional(str)
:param details: Returns extended information about nodes, such as
md5, binary, and or content. The valid options are ``basic`` and
``full``.
:type details: Optional(str)
dan
api: add a max_file_bytes parameter to get_nodes so that large...
r502 :param max_file_bytes: Only return file content under this file size bytes
:type details: Optional(int)
project: added all source files and assets
r1
Example output:
.. code-block:: bash
id : <id_given_in_input>
result: [
{
"name" : "<name>"
"type" : "<type>",
"binary": "<true|false>" (only in extended mode)
"md5" : "<md5 of file content>" (only in extended mode)
},
...
]
error: null
"""
repo = get_repo_or_error(repoid)
if not has_superadmin_permission(apiuser):
_perms = (
'repository.admin', 'repository.write', 'repository.read',)
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 validate_repo_permissions(apiuser, repoid, repo, _perms)
project: added all source files and assets
r1
ret_type = Optional.extract(ret_type)
details = Optional.extract(details)
_extended_types = ['basic', 'full']
if details not in _extended_types:
raise JSONRPCError(
'ret_type must be one of %s' % (','.join(_extended_types)))
extended_info = False
content = False
if details == 'basic':
extended_info = True
if details == 'full':
extended_info = content = True
_map = {}
try:
# check if repo is not empty by any chance, skip quicker if it is.
_scm = repo.scm_instance()
if _scm.is_empty():
return []
_d, _f = ScmModel().get_nodes(
repo, revision, root_path, flat=False,
dan
api: add a max_file_bytes parameter to get_nodes so that large...
r502 extended_info=extended_info, content=content,
max_file_bytes=max_file_bytes)
project: added all source files and assets
r1 _map = {
'all': _d + _f,
'files': _f,
'dirs': _d,
}
return _map[ret_type]
except KeyError:
raise JSONRPCError(
'ret_type must be one of %s' % (','.join(sorted(_map.keys()))))
except Exception:
log.exception("Exception occurred while trying to get repo nodes")
raise JSONRPCError(
'failed to get repo: `%s` nodes' % repo.repo_name
)
@jsonrpc_method()
def get_repo_refs(request, apiuser, repoid):
"""
Returns a dictionary of current references. It returns
bookmarks, branches, closed_branches, and tags for given repository
It's possible to specify ret_type to show only `files` or `dirs`.
This command can only be run using an |authtoken| with admin rights,
or users with at least read rights to |repos|.
:param apiuser: This is filled automatically from the |authtoken|.
:type apiuser: AuthUser
:param repoid: The repository name or repository ID.
:type repoid: str or int
Example output:
.. code-block:: bash
id : <id_given_in_input>
api: implemente missing get_repo_refs api backend. Fixes #4677
r1243 "result": {
"bookmarks": {
"dev": "5611d30200f4040ba2ab4f3d64e5b06408a02188",
"master": "367f590445081d8ec8c2ea0456e73ae1f1c3d6cf"
},
"branches": {
"default": "5611d30200f4040ba2ab4f3d64e5b06408a02188",
"stable": "367f590445081d8ec8c2ea0456e73ae1f1c3d6cf"
},
"branches_closed": {},
"tags": {
"tip": "5611d30200f4040ba2ab4f3d64e5b06408a02188",
"v4.4.0": "1232313f9e6adac5ce5399c2a891dc1e72b79022",
"v4.4.1": "cbb9f1d329ae5768379cdec55a62ebdd546c4e27",
"v4.4.2": "24ffe44a27fcd1c5b6936144e176b9f6dd2f3a17",
}
}
project: added all source files and assets
r1 error: null
"""
repo = get_repo_or_error(repoid)
if not has_superadmin_permission(apiuser):
_perms = ('repository.admin', 'repository.write', 'repository.read',)
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 validate_repo_permissions(apiuser, repoid, repo, _perms)
project: added all source files and assets
r1
try:
# check if repo is not empty by any chance, skip quicker if it is.
vcs_instance = repo.scm_instance()
refs = vcs_instance.refs()
return refs
except Exception:
log.exception("Exception occurred while trying to get repo refs")
raise JSONRPCError(
'failed to get repo: `%s` references' % repo.repo_name
)
@jsonrpc_method()
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 def create_repo(
request, apiuser, repo_name, repo_type,
owner=Optional(OAttr('apiuser')),
description=Optional(''),
private=Optional(False),
clone_uri=Optional(None),
repositories: allow properly updating repository push url.
r2562 push_uri=Optional(None),
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 landing_rev=Optional('rev:tip'),
enable_statistics=Optional(False),
enable_locking=Optional(False),
enable_downloads=Optional(False),
copy_permissions=Optional(False)):
project: added all source files and assets
r1 """
Creates a repository.
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 * If the repository name contains "/", repository will be created inside
a repository group or nested repository groups
project: added all source files and assets
r1
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 For example "foo/bar/repo1" will create |repo| called "repo1" inside
group "foo/bar". You have to have permissions to access and write to
the last repository group ("bar" in this example)
project: added all source files and assets
r1
This command can only be run using an |authtoken| with at least
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 permissions to create repositories, or write permissions to
parent repository groups.
project: added all source files and assets
r1
:param apiuser: This is filled automatically from the |authtoken|.
:type apiuser: AuthUser
:param repo_name: Set the repository name.
:type repo_name: str
:param repo_type: Set the repository type; 'hg','git', or 'svn'.
:type repo_type: str
:param owner: user_id or username
:type owner: Optional(str)
:param description: Set the repository description.
:type description: Optional(str)
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 :param private: set repository as private
project: added all source files and assets
r1 :type private: bool
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 :param clone_uri: set clone_uri
project: added all source files and assets
r1 :type clone_uri: str
repositories: allow properly updating repository push url.
r2562 :param push_uri: set push_uri
:type push_uri: str
project: added all source files and assets
r1 :param landing_rev: <rev_type>:<rev>
:type landing_rev: str
:param enable_locking:
:type enable_locking: bool
:param enable_downloads:
:type enable_downloads: bool
:param enable_statistics:
:type enable_statistics: bool
:param copy_permissions: Copy permission from group in which the
repository is being created.
:type copy_permissions: bool
Example output:
.. code-block:: bash
id : <id_given_in_input>
result: {
"msg": "Created new repository `<reponame>`",
"success": true,
"task": "<celery task id or None if done sync>"
}
error: null
Example error output:
.. code-block:: bash
id : <id_given_in_input>
result : null
error : {
docs: fixed small wanrings/errors during build.
r1120 'failed to create repository `<repo_name>`'
project: added all source files and assets
r1 }
"""
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 owner = validate_set_owner_permissions(apiuser, owner)
project: added all source files and assets
r1
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 description = Optional.extract(description)
copy_permissions = Optional.extract(copy_permissions)
clone_uri = Optional.extract(clone_uri)
repositories: allow properly updating repository push url.
r2562 push_uri = Optional.extract(push_uri)
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 landing_commit_ref = Optional.extract(landing_rev)
project: added all source files and assets
r1
defs = SettingsModel().get_default_repo_settings(strip_prefix=True)
if isinstance(private, Optional):
private = defs.get('repo_private') or Optional.extract(private)
if isinstance(repo_type, Optional):
repo_type = defs.get('repo_type')
if isinstance(enable_statistics, Optional):
enable_statistics = defs.get('repo_enable_statistics')
if isinstance(enable_locking, Optional):
enable_locking = defs.get('repo_enable_locking')
if isinstance(enable_downloads, Optional):
enable_downloads = defs.get('repo_enable_downloads')
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 schema = repo_schema.RepoSchema().bind(
repo_type_options=rhodecode.BACKENDS.keys(),
api: security, fix problem when absolute paths are specified with API call, that would allow...
r2664 repo_type=repo_type,
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 # user caller
user=apiuser)
project: added all source files and assets
r1
try:
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 schema_data = schema.deserialize(dict(
repo_name=repo_name,
repo_type=repo_type,
repo_owner=owner.username,
repo_description=description,
repo_landing_commit_ref=landing_commit_ref,
repo_clone_uri=clone_uri,
repositories: allow properly updating repository push url.
r2562 repo_push_uri=push_uri,
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 repo_private=private,
repo_copy_permissions=copy_permissions,
repo_enable_statistics=enable_statistics,
repo_enable_downloads=enable_downloads,
repo_enable_locking=enable_locking))
except validation_schema.Invalid as err:
raise JSONRPCValidationError(colander_exc=err)
try:
project: added all source files and assets
r1 data = {
'owner': owner,
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 'repo_name': schema_data['repo_group']['repo_name_without_group'],
'repo_name_full': schema_data['repo_name'],
'repo_group': schema_data['repo_group']['repo_group_id'],
'repo_type': schema_data['repo_type'],
'repo_description': schema_data['repo_description'],
'repo_private': schema_data['repo_private'],
'clone_uri': schema_data['repo_clone_uri'],
repositories: allow properly updating repository push url.
r2562 'push_uri': schema_data['repo_push_uri'],
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 'repo_landing_rev': schema_data['repo_landing_commit_ref'],
'enable_statistics': schema_data['repo_enable_statistics'],
'enable_locking': schema_data['repo_enable_locking'],
'enable_downloads': schema_data['repo_enable_downloads'],
'repo_copy_permissions': schema_data['repo_copy_permissions'],
project: added all source files and assets
r1 }
api: fixed problems with repository fork/create using celery backend....
r2683 task = RepoModel().create(form_data=data, cur_user=owner.user_id)
celery: celery 4.X support. Fixes #4169...
r2359 task_id = get_task_id(task)
project: added all source files and assets
r1 # no commit, it's done in RepoModel, or async via celery
return {
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 'msg': "Created new repository `%s`" % (schema_data['repo_name'],),
project: added all source files and assets
r1 'success': True, # cannot return the repo data here since fork
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 # can be done async
project: added all source files and assets
r1 'task': task_id
}
except Exception:
log.exception(
u"Exception while trying to create the repository %s",
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 schema_data['repo_name'])
project: added all source files and assets
r1 raise JSONRPCError(
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 'failed to create repository `%s`' % (schema_data['repo_name'],))
project: added all source files and assets
r1
@jsonrpc_method()
def add_field_to_repo(request, apiuser, repoid, key, label=Optional(''),
description=Optional('')):
"""
Adds an extra field to a repository.
This command can only be run using an |authtoken| with at least
write permissions to the |repo|.
:param apiuser: This is filled automatically from the |authtoken|.
:type apiuser: AuthUser
:param repoid: Set the repository name or repository id.
:type repoid: str or int
:param key: Create a unique field key for this repository.
:type key: str
:param label:
:type label: Optional(str)
:param description:
:type description: Optional(str)
"""
repo = get_repo_or_error(repoid)
if not has_superadmin_permission(apiuser):
_perms = ('repository.admin',)
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 validate_repo_permissions(apiuser, repoid, repo, _perms)
project: added all source files and assets
r1
label = Optional.extract(label) or key
description = Optional.extract(description)
field = RepositoryField.get_by_key_name(key, repo)
if field:
raise JSONRPCError('Field with key '
'`%s` exists for repo `%s`' % (key, repoid))
try:
RepoModel().add_repo_field(repo, key, field_label=label,
field_desc=description)
Session().commit()
return {
'msg': "Added new repository field `%s`" % (key,),
'success': True,
}
except Exception:
log.exception("Exception occurred while trying to add field to repo")
raise JSONRPCError(
'failed to create new field for repository `%s`' % (repoid,))
@jsonrpc_method()
def remove_field_from_repo(request, apiuser, repoid, key):
"""
Removes an extra field from a repository.
This command can only be run using an |authtoken| with at least
write permissions to the |repo|.
:param apiuser: This is filled automatically from the |authtoken|.
:type apiuser: AuthUser
:param repoid: Set the repository name or repository ID.
:type repoid: str or int
:param key: Set the unique field key for this repository.
:type key: str
"""
repo = get_repo_or_error(repoid)
if not has_superadmin_permission(apiuser):
_perms = ('repository.admin',)
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 validate_repo_permissions(apiuser, repoid, repo, _perms)
project: added all source files and assets
r1
field = RepositoryField.get_by_key_name(key, repo)
if not field:
raise JSONRPCError('Field with key `%s` does not '
'exists for repo `%s`' % (key, repoid))
try:
RepoModel().delete_repo_field(repo, field_key=key)
Session().commit()
return {
'msg': "Deleted repository field `%s`" % (key,),
'success': True,
}
except Exception:
log.exception(
"Exception occurred while trying to delete field from repo")
raise JSONRPCError(
'failed to delete field for repository `%s`' % (repoid,))
@jsonrpc_method()
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 def update_repo(
request, apiuser, repoid, repo_name=Optional(None),
owner=Optional(OAttr('apiuser')), description=Optional(''),
api: update pull method with possible specification of the url
r2563 private=Optional(False),
clone_uri=Optional(None), push_uri=Optional(None),
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 landing_rev=Optional('rev:tip'), fork_of=Optional(None),
enable_statistics=Optional(False),
enable_locking=Optional(False),
enable_downloads=Optional(False), fields=Optional('')):
project: added all source files and assets
r1 """
Updates a repository with the given information.
This command can only be run using an |authtoken| with at least
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 admin permissions to the |repo|.
* If the repository name contains "/", repository will be updated
accordingly with a repository group or nested repository groups
For example repoid=repo-test name="foo/bar/repo-test" will update |repo|
called "repo-test" and place it inside group "foo/bar".
You have to have permissions to access and write to the last repository
group ("bar" in this example)
project: added all source files and assets
r1
:param apiuser: This is filled automatically from the |authtoken|.
:type apiuser: AuthUser
:param repoid: repository name or repository ID.
:type repoid: str or int
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 :param repo_name: Update the |repo| name, including the
repository group it's in.
:type repo_name: str
project: added all source files and assets
r1 :param owner: Set the |repo| owner.
:type owner: str
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 :param fork_of: Set the |repo| as fork of another |repo|.
project: added all source files and assets
r1 :type fork_of: str
:param description: Update the |repo| description.
:type description: str
:param private: Set the |repo| as private. (True | False)
:type private: bool
:param clone_uri: Update the |repo| clone URI.
:type clone_uri: str
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 :param landing_rev: Set the |repo| landing revision. Default is ``rev:tip``.
project: added all source files and assets
r1 :type landing_rev: str
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 :param enable_statistics: Enable statistics on the |repo|, (True | False).
project: added all source files and assets
r1 :type enable_statistics: bool
:param enable_locking: Enable |repo| locking.
:type enable_locking: bool
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 :param enable_downloads: Enable downloads from the |repo|, (True | False).
project: added all source files and assets
r1 :type enable_downloads: bool
:param fields: Add extra fields to the |repo|. Use the following
example format: ``field_key=field_val,field_key2=fieldval2``.
Escape ', ' with \,
:type fields: str
"""
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153
project: added all source files and assets
r1 repo = get_repo_or_error(repoid)
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153
project: added all source files and assets
r1 include_secrets = False
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153 if not has_superadmin_permission(apiuser):
validate_repo_permissions(apiuser, repoid, repo, ('repository.admin',))
else:
project: added all source files and assets
r1 include_secrets = True
repo-schemas: refactor repository schemas and use it in API update/create functions....
r1153
updates = dict(
repo_name=repo_name
if not isinstance(repo_name, Optional) else repo.repo_name,
fork_id=fork_of
if not isinstance(fork_of, Optional) else repo.fork.repo_name if repo.fork else None,
user=owner
if not isinstance(owner, Optional) else repo.user.username,
repo_description=description
if not isinstance(description, Optional) else repo.description,
repo_private=private
if not isinstance(private, Optional) else repo.private,
clone_uri=clone_uri
if not isinstance(clone_uri, Optional) else repo.clone_uri,