19086c5de05f4984d7a90cd31624c45dd893f6bb 0.4.0

da65398a62fff50f3d241796cbf17acdea2092ef 0.4.1

bfa0b0a814644f0af3f492d17a9ed169cc3b89fe 0.5.0

List of contributors to Kallithea project:

    Andrej Shadura <andrew@shadura.me> 2012 2014-2017 2019

    Étienne Gilli <etienne.gilli@gmail.com> 2015-2017 2019

    Allan Nordhøy <epost@anotheragency.no> 2017-2019

    ssantos <ssantos@web.de> 2018-2019

    Danni Randeris <danniranderis@gmail.com> 2019

    Edmund Wong <ewong@crazy-cat.org> 2019

    Elizabeth Sherrock <lizzyd710@gmail.com> 2019

    Mateusz Mendel <mendelm9@gmail.com> 2019

    Nathan <bonnemainsnathan@gmail.com> 2019

    Oleksandr Shtalinberg <o.shtalinberg@gmail.com> 2019

    THANOS SIOURDAKIS <siourdakisthanos@gmail.com> 2019

    Wolfgang Scherer <wolfgang.scherer@gmx.de> 2019

    Христо Станев <hstanev@gmail.com> 2019

static_files = true

## Internationalization (see setup documentation for details)

cache_dir = %(here)s/data

index_dir = %(here)s/data/index

# General information about the project.

project = u'Kallithea'

# The version info for the project you're documenting, acts as replacement for

# |version| and |release|, also used in various other places throughout the

language, as indicated by the browser. Thus, different users may see the

application in different languages. If the requested language is not available

(because the translation file for that language does not yet exist or is

If you want to disable automatic language detection and instead configure a

fixed language regardless of user preference, set ``i18n.enabled = false`` and

Using Kallithea with SSH

      ini = '/srv/kallithea/my.ini'

      from logging.config import fileConfig

      from paste.deploy import loadapp

      application = loadapp('config:' + ini)

      ini = '/srv/kallithea/kallithea.ini'

      from logging.config import fileConfig

      from paste.deploy import loadapp

      application = loadapp('config:' + ini)

# Alembic migration environment (configuration).

import logging

from logging.config import fileConfig

from alembic import context

# stamping during "kallithea-cli db-create"), config_file_name is not available,

# and loggers are assumed to already have been configured.

if config.config_file_name:

def include_in_autogeneration(object, name, type, reflected, compare_to):

def upgrade():

def downgrade():

    with op.batch_alter_table('user_ssh_keys', schema=None) as batch_op:

        batch_op.drop_index('usk_public_key_idx')

                path_to_ini_file = os.path.realpath(config_file)

                kallithea.CONFIG = paste.deploy.appconfig('config:' + path_to_ini_file)

                config_string = read_config(path_to_ini_file, strip_section_prefix=annotated.__name__)

                if config_file_initialize_app:

                    kallithea.config.middleware.make_app_without_logging(kallithea.CONFIG.global_conf, **kallithea.CONFIG.local_conf)

                return annotated(*args, **kwargs)

def __ExtensionFactory__():

    from paste.deploy import loadapp

    from logging.config import fileConfig

    application = loadapp('config:%(inifile)s')

    def app(environ, start_response):

    with open(dispatchfile, 'w') as f:

        f.write(dispath_py_template % {

            'inifile': config_file_abs.replace('\\', '\\\\'),

            'virtualdir': virtualdir,

            })

from kallithea.lib.utils2 import str2bool

from kallithea.lib.vcs.backends.git.ssh import GitSshHandler

from kallithea.lib.vcs.backends.hg.ssh import MercurialSshHandler

log = logging.getLogger(__name__)

    The file is usually maintained automatically, but this command will also re-write it.

    """

    SshKeyModel().write_authorized_keys()

        # Disable transaction manager -- currently Kallithea takes care of transactions itself

        self['tm.enabled'] = False

base_config = KallitheaAppConfig()

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

"""WSGI middleware initialization for the Kallithea application."""

from kallithea.config.app_cfg import base_config

from kallithea.config.environment import load_environment

    ``app_conf`` contains all the application-specific settings (those defined

    under ``[app:main]``.

    """

    return make_app_without_logging(global_conf, full_stack=full_stack, **app_conf)

    @IfSshEnabled

    def my_account_ssh_keys_delete(self):

        try:

            Session().commit()

            SshKeyModel().write_authorized_keys()

            h.flash(_("SSH key successfully deleted"), category='success')

    def ssh_keys_delete(self, id):

        c.user = self._get_user_or_raise_if_default(id)

        try:

            Session().commit()

            SshKeyModel().write_authorized_keys()

            h.flash(_("SSH key successfully deleted"), category='success')

        # The template needs the email address outside of the form.

        c.email = request.params.get('email')

        if not request.POST:

        form = PasswordResetConfirmationForm()()

        try:

import itertools

import logging

import os

import ipaddr

from decorator import decorator

    :param password: password

    :param hashed: password in hashed form

    """

        return hashlib.sha256(safe_bytes(password)).hexdigest() == hashed

    elif is_unix:

        import bcrypt

"""

import os

import time

import mercurial.scmutil

from kallithea.lib import helpers as h

from kallithea.lib.exceptions import UserCreationError

from kallithea.lib.utils import action_logger, make_ui

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

from kallithea.model.db import Repository, User

def handle_git_post_receive(repo_path, git_stdin_lines):

    """Called from Git post-receive hook"""

    baseui, repo = _hook_environment(repo_path)

    # the post push hook should never use the cached instance

    scm_repo = repo.scm_instance_no_cache()

static_files = true

<%text>## Internationalization (see setup documentation for details)</%text>

cache_dir = %(here)s/data

index_dir = %(here)s/data/index

    >>> parse_pub_key('''AAAAB3NzaC1yc2EAAAALVGhpcyBpcyBmYWtlIQ''')

    Traceback (most recent call last):

    ...

    >>> parse_pub_key('''abc AAAAB3NzaC1yc2EAAAALVGhpcyBpcyBmYWtlIQ''')

    Traceback (most recent call last):

    ...

    parts = ssh_key.split(None, 2)

    if len(parts) < 2:

    keytype, keyvalue, comment = (parts + [''])[:3]

    if keytype not in ('ssh-rsa', 'ssh-dss', 'ssh-ed25519'):

SSH_OPTIONS = 'no-pty,no-port-forwarding,no-X11-forwarding,no-agent-forwarding'

def authorized_keys_line(kallithea_cli_path, config_file, key):

    """

    Return a line as it would appear in .authorized_keys

        return '# Invalid Kallithea SSH key: %s %s\n' % (key.user.user_id, key.user_ssh_key_id)

    base64_key = ascii_str(base64.b64encode(key_bytes))

    assert '\n' not in base64_key

    return '%s,command="%s ssh-serve -c %s %s %s" %s %s\n' % (

        SSH_OPTIONS, kallithea_cli_path, config_file,

        key.user.user_id, key.user_ssh_key_id,

    return str(_url)

def get_hook_environment():

    """

    Get hook context by deserializing the global KALLITHEA_EXTRAS environment

    """

    try:

    except KeyError:

    try:

            extras[k]

    except KeyError:

    return AttributeDict(extras)

class UserSshKeys(Base, BaseDbModel):

    __tablename__ = 'user_ssh_keys'

    __table_args__ = (

        Index('usk_fingerprint_idx', 'fingerprint'),

        UniqueConstraint('fingerprint'),

        _table_args_default_dict

from kallithea.lib import ssh

from kallithea.lib.utils2 import str2bool

from kallithea.model.db import User, UserSshKeys

from kallithea.model.meta import Session

log = logging.getLogger(__name__)

    """Exception raised by SshKeyModel methods to report errors"""

        return new_ssh_key

        """

        Will raise SshKeyModelException on errors

        """

            user = User.guess_instance(user)

            ssh_key = ssh_key.filter(UserSshKeys.user_id == user.user_id)

        ssh_key = ssh_key.scalar()

        if ssh_key is None:

        Session().delete(ssh_key)

    def get_ssh_keys(self, user):

        # Now, test that the directory is or was created in a readable way by previous.

        if not (os.path.isdir(authorized_keys_dir) and

                os.access(authorized_keys_dir, os.W_OK)):

        # Make sure we don't overwrite a key file with important content

        if os.path.exists(authorized_keys):

                    elif ssh.SSH_OPTIONS in l and ' ssh-serve ' in l:

                        pass # Kallithea entries are ok to overwrite

                    else:

        fh, tmp_authorized_keys = tempfile.mkstemp('.authorized_keys', dir=os.path.dirname(authorized_keys))

        with os.fdopen(fh, 'w') as f:

            for key in UserSshKeys.query().join(UserSshKeys.user).filter(User.active == True):

                f.write(ssh.authorized_keys_line(kallithea_cli_path, config['__file__'], key))

        os.chmod(tmp_authorized_keys, stat.S_IRUSR | stat.S_IWUSR)

  necessarily limited to the following:</p>

  <ul>

  <li>Copyright &copy; 2012, 2014&ndash;2017, 2019, Andrej Shadura</li>

  <li>Copyright &copy; 2015&ndash;2017, 2019, Étienne Gilli</li>

  <li>Copyright &copy; 2017&ndash;2019, Allan Nordhøy</li>

  <li>Copyright &copy; 2018&ndash;2019, ssantos</li>

  <li>Copyright &copy; 2019, Danni Randeris</li>

  <li>Copyright &copy; 2019, Edmund Wong</li>

  <li>Copyright &copy; 2019, Elizabeth Sherrock</li>

  <li>Copyright &copy; 2019, Mateusz Mendel</li>

  <li>Copyright &copy; 2019, Nathan</li>

  <li>Copyright &copy; 2019, Oleksandr Shtalinberg</li>

  <li>Copyright &copy; 2019, THANOS SIOURDAKIS</li>

  <li>Copyright &copy; 2019, Wolfgang Scherer</li>

  <li>Copyright &copy; 2019, Христо Станев</li>

            </td>

            <td>

                ${h.form(url('my_account_ssh_keys_delete'))}

                    <button class="btn btn-danger btn-xs" type="submit"

                            onclick="return confirm('${_('Confirm to remove this SSH key: %s') % ssh_key.fingerprint}');">

                        <i class="icon-trashcan"></i>

            </td>

            <td>

                ${h.form(url('edit_user_ssh_keys_delete', id=c.user.user_id))}

                    <button class="btn btn-danger btn-xs" type="submit"

                            onclick="return confirm('${_('Confirm to remove this SSH key: %s') % ssh_key.fingerprint}');">

                        <i class="icon-trashcan"></i>

            <a class="navbar-link" href="${h.url('kallithea_project_url')}" target="_blank">Kallithea</a>,

        %endif

        which is

        %if c.issues_url:

            &ndash; <a class="navbar-link" href="${c.issues_url}" target="_blank">${_('Support')}</a>

        %endif

        ${h.form(h.url('reset_password_confirmation'), method='post')}

        <p>${_('You are about to set a new password for the email address %s.') % c.email}</p>

        <p>${_('Note that you must use the same browser session for this as the one used to request the password reset.')}</p>

        <div class="form">

                <div class="form-group">

                    <label class="control-label" for="token">${_('Code you received in the email')}:</label>

                    <div>

                    </div>

                </div>

        assert ssh_key.description == u'me@localhost'

        response = self.app.post(base.url('edit_user_ssh_keys_delete', id=user_id),

                                  '_session_csrf_secret_token': self.session_csrf_secret_token()})

        self.checkSessionFlash(response, 'SSH key successfully deleted')

        keys = UserSshKeys.query().all()

import time

import urlparse

from tg.util.webtest import test_context

from kallithea.lib import helpers as h

from kallithea.lib.auth import check_password

from kallithea.lib.utils2 import generate_api_key

        Session().add(new)

        Session().commit()

        response = self.app.post(base.url(controller='login',

                                     action='password_reset'),

                                 {'email': email,

        self.checkSessionFlash(response, 'A password reset confirmation code has been sent')

        response = response.follow()

        # BAD TOKEN

        response = self.app.post(base.url(controller='login',

                                     action='password_reset_confirmation'),

                                  'timestamp': timestamp,

                                  'password': "p@ssw0rd",

                                  'password_confirm': "p@ssw0rd",

                                  '_session_csrf_secret_token': self.session_csrf_secret_token(),

                                 })

        assert response.status == '200 OK'

        # GOOD TOKEN

        assert response.status == '200 OK'

        response.mustcontain("You are about to set a new password for the email address %s" % email)

        response = self.app.post(base.url(controller='login',

                                     action='password_reset_confirmation'),

                                 {'email': email,

        assert ssh_key.description == u'me@localhost'

        response = self.app.post(base.url('my_account_ssh_keys_delete'),

                                  '_session_csrf_secret_token': self.session_csrf_secret_token()})

        self.checkSessionFlash(response, 'SSH key successfully deleted')

        keys = UserSshKeys.query().all()

echo "Releasing Kallithea $version in directory $namerel"

echo "Verify dist file content"

echo "Verify docs build"

python2 setup.py build_sphinx # the results are not actually used, but we want to make sure it builds

    for year, name in all_entries:

        if name in no_entries or (name, year) in no_entries:

            continue

        domain = name.split('@', 1)[-1].rstrip('>')

        if domain in domain_extra:

            name_years[domain_extra[domain]].add(year)

pip install -e . -r "$min_requirements" python-ldap python-pam 2> >(tee "$log" >&2)

# Strip out the known Python 2.7 deprecation message.

# Treat any message on stderr as a problem, for the caller to interpret.

if [ -s "$log" ]; then