- Based on Pylons, SQLAlchemy, SQLite, Whoosh, vcs.

License

-------

**Kallithea** is released under the GPLv3 license. Kallithea is a `Software

Freedom Conservancy`_ project and thus controlled by a non-profit organization.

No commercial entity can take ownership of the project and change the

direction.

Kallithea started out as an effort to make sure the existing GPLv3 codebase

would stay available under a legal license. Kallithea thus has to stay GPLv3

compatible ... but we are also happy it is GPLv3 and happy to keep it that way.

A different license (such as AGPL) could perhaps help attract a different

community with a different mix of Free Software people and companies but we are

happy with the current focus.

Community

---------

**Kallithea** is maintained by its users who contribute the fixes they would

like to see.

Get in touch with the rest of the community:

- Join the mailing list users and developers -- see

  http://lists.sfconservancy.org/mailman/listinfo/kallithea-general.

- Use IRC and join #kallithea on FreeNode (irc.freenode.net) or use

  http://webchat.freenode.net/?channels=kallithea.

- Follow Kallithea on Twitter, **@KallitheaSCM**.

- Issues can be reported at `issue tracker

  <https://bitbucket.org/conservancy/kallithea/issues>`_.

   .. note::

       Please try to read the documentation before posting any issues,

       especially the **troubleshooting section**

Online documentation

--------------------

Online documentation for the current version of Kallithea is available at

You can also build the documentation locally: go to ``docs/`` and run::

   make html

.. note:: You need to have Sphinx_ installed to build the

          documentation. If you don't have Sphinx_ installed you can

          install it via the command: ``pip install sphinx`` .

Migrating from RhodeCode

------------------------

Kallithea 0.3.2 and earlier supports migrating from an existing RhodeCode

installation. To migrate, install Kallithea 0.3.2 and follow the

instructions in the 0.3.2 README to perform a one-time conversion of the

database from RhodeCode to Kallithea, before upgrading to this version

of Kallithea.

.. _virtualenv: http://pypi.python.org/pypi/virtualenv

.. _Python: http://www.python.org/

.. _Sphinx: http://sphinx.pocoo.org/

.. _Mercurial: http://mercurial.selenic.com/

.. _Bitbucket: http://bitbucket.org/

.. _GitHub: http://github.com/

.. _Subversion: http://subversion.tigris.org/

.. _Git: http://git-scm.com/

.. _Celery: http://celeryproject.org/

.. _vcs: http://pypi.python.org/pypi/vcs

.. _Software Freedom Conservancy: http://sfconservancy.org/

.. _Puppet module: https://forge.puppetlabs.com/rauch/kallithea

configuration file is used as fallback. If no fallback language is explicitly

specified, English is used.

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

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

set ``i18n.lang`` to the desired language (or leave empty for English).

Using Kallithea with SSH

------------------------

Kallithea currently only hosts repositories using http and https. (The addition

of ssh hosting is a planned future feature.) However you can easily use ssh in

parallel with Kallithea. (Repository access via ssh is a standard "out of

the box" feature of Mercurial_ and you can use this to access any of the

repositories that Kallithea is hosting. See PublishingRepositories_)

Kallithea repository structures are kept in directories with the same name

as the project. When using repository groups, each group is a subdirectory.

This allows you to easily use ssh for accessing repositories.

In order to use ssh you need to make sure that your web server and the users'

login accounts have the correct permissions set on the appropriate directories.

.. note:: These permissions are independent of any permissions you

          have set up using the Kallithea web interface.

If your main directory (the same as set in Kallithea settings) is for

example set to ``/srv/repos`` and the repository you are using is

named ``kallithea``, then to clone via ssh you should run::

    hg clone ssh://user@kallithea.example.com/srv/repos/kallithea

Using other external tools such as mercurial-server_ or using ssh key-based

authentication is fully supported.

.. note:: In an advanced setup, in order for your ssh access to use

          the same permissions as set up via the Kallithea web

          interface, you can create an authentication hook to connect

          to the Kallithea db and run check functions for permissions

          against that.

Setting up Whoosh full text search

----------------------------------

Kallithea provides full text search of repositories using `Whoosh`__.

For an incremental index build, run::

    gearbox make-index -c my.ini

For a full index rebuild, run::

    gearbox make-index -c my.ini -f

The ``--repo-location`` option allows the location of the repositories to be overridden;

usually, the location is retrieved from the Kallithea database.

The ``--index-only`` option can be used to limit the indexed repositories to a comma-separated list::

    gearbox make-index -c my.ini --index-only=vcs,kallithea

To keep your index up-to-date it is necessary to do periodic index builds;

for this, it is recommended to use a crontab entry. Example::

    0  3  *  *  *  /path/to/virtualenv/bin/gearbox make-index -c /path/to/kallithea/my.ini

When using incremental mode (the default), Whoosh will check the last

modification date of each file and add it to be reindexed if a newer file is

available. The indexing daemon checks for any removed files and removes them

from index.

If you want to rebuild the index from scratch, you can use the ``-f`` flag as above,

or in the admin panel you can check the "build from scratch" checkbox.

.. _ldap-setup:

Setting up LDAP support

-----------------------

Kallithea supports LDAP authentication. In order

to use LDAP, you have to install the python-ldap_ package. This package is

available via PyPI, so you can install it by running::

    pip install python-ldap

.. note:: ``python-ldap`` requires some libraries to be installed on

          your system, so before installing it check that you have at

          least the ``openldap`` and ``sasl`` libraries.

Choose *Admin > Authentication*, click the ``kallithea.lib.auth_modules.auth_ldap`` button

and then *Save*, to enable the LDAP plugin and configure its settings.

from gearbox.command import Command

class UpgradeDb(Command):

    '''(removed)'''

    deprecated = True

    def run(self, args):

        raise SystemExit(

            'The "paster upgrade-db" command has been removed; please see the docs:\n'

        )

hg up -cr .

echo "Make release build from clean checkout in build/"

rm -rf build dist

hg archive build

cd build

echo "Check MANIFEST.in"

sed -e 's/[^ ]*[ ]*\([^ ]*\).*/\1/g' MANIFEST.in | grep -v '^node_modules/bootstrap\|^kallithea/public/css/style.css' | xargs ls -lad

echo "Build dist"

python2 setup.py compile_catalog

python2 setup.py sdist

echo "Verify VERSION from kallithea/__init__.py"

namerel=$(cd dist && echo Kallithea-*.tar.gz)

namerel=${namerel%.tar.gz}

version=${namerel#Kallithea-}

ls -l $(pwd)/dist/$namerel.tar.gz

echo "Releasing Kallithea $version in directory $namerel"

echo "Verify dist file content"

diff -u <((hg mani | grep -v '^\.hg') | LANG=C sort) <(tar tf dist/Kallithea-$version.tar.gz | sed "s|^$namerel/||" | grep . | grep -v '^kallithea/i18n/.*/LC_MESSAGES/kallithea.mo$\|^Kallithea.egg-info/\|^PKG-INFO$\|/$' | LANG=C sort)

! tar tf dist/Kallithea-$version.tar.gz | grep "$namerel/node_modules/bootstrap/\$"

echo "Verify docs build"

python2 setup.py build_sphinx # not used yet ... but we want to make sure it builds

cat - << EOT

Now, make sure

* all tests are passing

* release note is ready

* announcement is ready

* source has been pushed to https://kallithea-scm.org/repos/kallithea

EOT

echo "Verify current revision is tagged for $version"

hg log -r "'$version'&." | grep .

echo -n "Enter \"pypi\" to upload Kallithea $version to pypi: "

read answer

[ "$answer" = "pypi" ]

echo "Upload docs to pypi"

# See https://wiki.python.org/moin/PyPiDocumentationHosting

python2 setup.py build_sphinx upload_sphinx

xdg-open http://packages.python.org/Kallithea/installation.html

echo "Rebuild readthedocs for docs.kallithea-scm.org"

xdg-open https://readthedocs.org/projects/kallithea/

curl -X POST http://readthedocs.org/build/kallithea

xdg-open https://readthedocs.org/builds/kallithea/

xdg-open http://docs.kallithea-scm.org/en/latest/ # or whatever the branch is

extraargs=${EMAIL:+--identity=$EMAIL}

python2 setup.py sdist upload --sign $extraargs

xdg-open https://pypi.python.org/pypi/Kallithea