import logging

import re

from kallithea.config.middleware.pygrack import make_wsgi_app

from kallithea.lib.base import BaseVCSController, get_path_info

from kallithea.lib.utils import make_ui

from kallithea.model import db

log = logging.getLogger(__name__)

                parsed_request.service == 'git-upload-pack'

            ):

                baseui = make_ui()

                repo = db.Repository.get_by_repo_name(parsed_request.repo_name)

                scm_repo = repo.scm_instance

                # Run hooks, like Mercurial outgoing.pull_logger does

            # Note: push hooks are handled by post-receive hook

            return pygrack_app(environ, start_response)

        return wrapper_app

import celery.utils.log

from tg import config

import kallithea

import kallithea.lib.helpers as h

from kallithea.lib.indexers.daemon import WhooshIndexingDaemon

from kallithea.lib.utils import action_logger

from kallithea.lib.utils2 import asbool, ascii_bytes

from kallithea.lib.vcs.utils import author_email

from kallithea.model import db

from kallithea.model.repo import RepoModel

            repo_name=repo_name,

            repo_type=repo_type,

            repo_group=db.RepoGroup.guess_instance(repo_group),

            clone_uri=clone_uri,

        )

        repo = db.Repository.get_by_repo_name(repo_name_full)

        # update repo changeset caches initially

        repo.update_changeset_cache()

        # set new created state

        repo.set_state(db.Repository.STATE_CREATED)

            repo_name=repo_name,

            repo_type=repo_type,

            repo_group=db.RepoGroup.guess_instance(repo_group),

            clone_uri=source_repo_path,

        )

        repo = db.Repository.get_by_repo_name(repo_name_full)

        # update repo changeset caches initially

        repo.update_changeset_cache()

        # set new created state

        repo.set_state(db.Repository.STATE_CREATED)

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import logging

import os

from kallithea.lib.utils import make_ui

from kallithea.lib.vcs.ssh import base

log = logging.getLogger(__name__)

        base.BaseSshHandler.__init__(self, repo_name)

        self.verb = verb

    def _serve(self):

        if self.verb == 'git-upload-pack': # action 'pull'

            # base class called set_hook_environment - action is hardcoded to 'pull'

        else: # probably verb 'git-receive-pack', action 'push'

            if not self.allow_push:

                self.exit('Push access to %r denied' % self.repo_name)

            # Note: push logging is handled by Git post-receive hook

        # git shell is not a real shell but use shell inspired quoting *inside* the argument.

import logging

import re

from tg import request

from tg.i18n import ugettext as _

from kallithea.lib.utils import extract_mentioned_users

from kallithea.lib.utils2 import ascii_bytes, short_ref_name, shorter

from kallithea.model import changeset_status, comment, db, meta, notification

log = logging.getLogger(__name__)

            pull_request=pr,

        )

        mention_recipients = extract_mentioned_users(self.description)

        PullRequestModel().add_reviewers(created_by, pr, self.reviewers, mention_recipients)

        return pr

class CreatePullRequestIterationAction(object):

    @staticmethod

import os

import shutil

import traceback

from datetime import datetime

import kallithea.lib.utils2

from kallithea.lib.auth import HasRepoPermissionLevel, HasUserGroupPermissionLevel

from kallithea.lib.exceptions import AttachedForksError

from kallithea.lib.utils import is_valid_repo_uri, make_ui

from kallithea.lib.utils2 import LazyProperty, get_current_authuser, obfuscate_url_pw, remove_prefix

from kallithea.lib.vcs.backends import get_backend

from kallithea.model import db, meta, scm

            try:

                meta.Session().delete(repo)

                if fs_remove:

                    self._delete_filesystem_repo(repo)

                else:

                    log.debug('skipping removal from filesystem')

                                      deleted_by=cur_user)

            except Exception:

                log.error(traceback.format_exc())

                raise

    def grant_user_permission(self, repo, user, perm):

import traceback

import pkg_resources

from tg.i18n import ugettext as _

import kallithea

from kallithea.lib.auth import HasPermissionAny, HasRepoGroupPermissionLevel, HasRepoPermissionLevel, HasUserGroupPermissionLevel

from kallithea.lib.exceptions import IMCCommitError, NonRelativePathError

from kallithea.lib.utils import action_logger, get_filesystem_repos, make_ui

from kallithea.lib.utils2 import safe_bytes, safe_str, set_hook_environment, umask

from kallithea.lib.vcs import get_repo

from kallithea.lib.vcs.backends.base import EmptyChangeset

from kallithea.lib.vcs.exceptions import RepositoryError, VCSError

from kallithea.lib.vcs.nodes import FileNode

        :param username: username who pushes

        :param action: push/push_local/push_remote

        :param repo_name: name of repo

        :param revisions: list of revisions that we pushed

        """

        set_hook_environment(username, ip_addr, repo_name, repo_alias=repo.alias, action=action)

    def pull_changes(self, repo, username, ip_addr, clone_uri=None):

        """

        Pull from "clone URL" or fork origin.

        """

        dbrepo = self.__get_repo(repo)

import traceback

from sqlalchemy.exc import DatabaseError

from tg import config

from tg.i18n import ugettext as _

from kallithea.lib.exceptions import DefaultUserException, UserOwnsReposException

from kallithea.lib.utils2 import check_password, generate_api_key, get_crypt_password, get_current_authuser

from kallithea.model import db, forms, meta

log = logging.getLogger(__name__)

        return db.User.guess_instance(user)

    def create(self, form_data, cur_user=None):

        if not cur_user:

            cur_user = getattr(get_current_authuser(), 'username', None)

        _fd = form_data

        user_data = {

            'username': _fd['username'],

            'password': _fd['password'],

            'email': _fd['email'],

            'firstname': _fd['firstname'],

            'lastname': _fd['lastname'],

            'active': _fd['active'],

            'admin': False

        }

        # raises UserCreationError if it's not allowed

        new_user = db.User()

        for k, v in form_data.items():

            if k == 'password':

                v = get_crypt_password(v)

            if k == 'firstname':

            setattr(new_user, k, v)

        new_user.api_key = generate_api_key()

        meta.Session().add(new_user)

        meta.Session().flush() # make database assign new_user.user_id

        return new_user

    def create_or_update(self, username, password, email, firstname='',

                         lastname='', active=True, admin=False,

                         extern_type=None, extern_name=None, cur_user=None):

        """

        :param extern_type:

        :param cur_user:

        """

        if not cur_user:

            cur_user = getattr(get_current_authuser(), 'username', None)

        user_data = {

            'username': username, 'password': password,

            'email': email, 'firstname': firstname, 'lastname': lastname,

            'active': active, 'admin': admin

        }

        # raises UserCreationError if it's not allowed

        log.debug('Checking for %s account in Kallithea database', username)

        user = db.User.get_by_username(username, case_insensitive=True)

        if user is None:

            log.debug('creating new user %s', username)

            new_user = db.User()

            if user is None:

                meta.Session().add(new_user)

                meta.Session().flush() # make database assign new_user.user_id

            if not edit:

            return new_user

        except (DatabaseError,):

            log.error(traceback.format_exc())

            raise

            raise UserOwnsReposException(

                _('User "%s" still owns %s user groups and cannot be '

                  'removed. Switch owners or remove those user groups: %s')

                % (user.username, len(usergroups), ', '.join(usergroups)))

        meta.Session().delete(user)

    def can_change_password(self, user):

        from kallithea.lib import auth_modules

        managed_fields = auth_modules.get_managed_fields(user)

        return 'password' not in managed_fields