.. _changelog:

=========

Changelog

=========

1.4.1 (**2012-09-05**)

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

:status: in-progress

:branch: beta

news

++++

- always put a comment about code-review status change even if user send

  empty data 

- modified_on column saves repository update and it's going to be used

  later for light version of main page ref #500

- pull request notifications send much nicer emails with details about pull

  request

fixes

+++++

- fixed migrations of permissions that can lead to inconsistency.

  Some users sent feedback that after upgrading from older versions issues 

  with updating default permissions occurred. RhodeCode detects that now and

  resets default user permission to initial state if there is a need for that.

  Also forces users to set the default value for new forking permission. 

- #535 improved apache wsgi example configuration in docs

- fixes #550 mercurial repositories comparision failed when origin repo had

  additional not-common changesets

- fixed status of code-review in preview windows of pull request

1.4.0 (**2012-09-03**)

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

news

++++

- new codereview system

- email map, allowing users to have multiple email addresses mapped into

  their accounts

- improved git-hook system. Now all actions for git are logged into journal

  including pushed revisions, user and IP address

- changed setup-app into setup-rhodecode and added default options to it.

- new git repos are created as bare now by default

- #464 added links to groups in permission box

- #465 mentions autocomplete inside comments boxes

- #469 added --update-only option to whoosh to re-index only given list

  of repos in index 

- rhodecode-api CLI client

- new git http protocol replaced buggy dulwich implementation.

  Now based on pygrack & gitweb

- Improved RSS/ATOM feeds. Discoverable by browsers using proper headers, and 

  reformated based on user suggestions. Additional rss/atom feeds for user

  journal

- various i18n improvements

- #478 permissions overview for admin in user edit view

- File view now displays small gravatars off all authors of given file

- Implemented landing revisions. Each repository will get landing_rev attribute

  that defines 'default' revision/branch for generating readme files

- Implemented #509, RhodeCode enforces SSL for push/pulling if requested at 

  earliest possible call.

- Import remote svn repositories to mercurial using hgsubversion.

- Fixed #508 RhodeCode now has a option to explicitly set forking permissions

- RhodeCode can use alternative server for generating avatar icons

- implemented repositories locking. Pull locks, push unlocks. Also can be done

  via API calls

- #538 form for permissions can handle multiple users at once 

fixes

+++++

- improved translations

- fixes issue #455 Creating an archive generates an exception on Windows

- fixes #448 Download ZIP archive keeps file in /tmp open and results 

  in out of disk space

- fixes issue #454 Search results under Windows include proceeding

  backslash

- fixed issue #450. Rhodecode no longer will crash when bad revision is

  present in journal data.

- fix for issue #417, git execution was broken on windows for certain

  commands.

- fixed #413. Don't disable .git directory for bare repos on deleting

- fixed issue #459. Changed the way of obtaining logger in reindex task.

- fixed #453 added ID field in whoosh SCHEMA that solves the issue of

  reindexing modified files

- fixed #481 rhodecode emails are sent without Date header 

- fixed #458 wrong count when no repos are present

- fixed issue #492 missing `\ No newline at end of file` test at the end of 

  new chunk in html diff

- full text search now works also for commit messages

1.3.6 (**2012-05-17**)

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

news

++++

- chinese traditional translation

- changed setup-app into setup-rhodecode and added arguments for auto-setup 

  mode that doesn't need user interaction 

fixes

+++++

- fixed no scm found warning

- fixed __future__ import error on rcextensions

- made simplejson required lib for speedup on JSON encoding

- fixes #449 bad regex could get more than revisions from parsing history

- don't clear DB session when CELERY_EAGER is turned ON

1.3.5 (**2012-05-10**)

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

news

++++

- use ext_json for json module

- unified annotation view with file source view

- notification improvements, better inbox + css

- #419 don't strip passwords for login forms, make rhodecode 

  more compatible with LDAP servers

- Added HTTP_X_FORWARDED_FOR as another method of extracting 

  IP for pull/push logs. - moved all to base controller  

- #415: Adding comment to changeset causes reload. 

  Comments are now added via ajax and doesn't reload the page

- #374 LDAP config is discarded when LDAP can't be activated

- limited push/pull operations are now logged for git in the journal

- bumped mercurial to 2.2.X series

- added support for displaying submodules in file-browser

- #421 added bookmarks in changelog view

fixes

+++++

- fixed dev-version marker for stable when served from source codes

- fixed missing permission checks on show forks page

- #418 cast to unicode fixes in notification objects

- #426 fixed mention extracting regex

- fixed remote-pulling for git remotes remopositories

- fixed #434: Error when accessing files or changesets of a git repository 

  with submodules

- fixed issue with empty APIKEYS for users after registration ref. #438

- fixed issue with getting README files from git repositories

1.3.4 (**2012-03-28**)

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

news

++++

- Whoosh logging is now controlled by the .ini files logging setup

- added clone-url into edit form on /settings page

- added help text into repo add/edit forms

- created rcextensions module with additional mappings (ref #322) and

  post push/pull/create repo hooks callbacks

- implemented #377 Users view for his own permissions on account page

- #399 added inheritance of permissions for users group on repos groups

- #401 repository group is automatically pre-selected when adding repos 

  inside a repository group

- added alternative HTTP 403 response when client failed to authenticate. Helps 

  solving issues with Mercurial and LDAP

- #402 removed group prefix from repository name when listing repositories 

  inside a group

- added gravatars into permission view and permissions autocomplete

- #347 when running multiple RhodeCode instances, properly invalidates cache 

  for all registered servers

fixes

+++++

- fixed #390 cache invalidation problems on repos inside group

- fixed #385 clone by ID url was loosing proxy prefix in URL

- fixed some unicode problems with waitress

- fixed issue with escaping < and > in changeset commits

- fixed error occurring during recursive group creation in API 

  create_repo function

- fixed #393 py2.5 fixes for routes url generator

- fixed #397 Private repository groups shows up before login

- fixed #396 fixed problems with revoking users in nested groups

- fixed mysql unicode issues + specified InnoDB as default engine with 

  utf8 charset

- #406 trim long branch/tag names in changelog to not break UI

1.3.3 (**2012-03-02**)

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

news

++++

fixes

+++++

- fixed some python2.5 compatibility issues 

- fixed issues with removed repos was accidentally added as groups, after

  full rescan of paths

- fixes #376 Cannot edit user (using container auth)

- fixes #378 Invalid image urls on changeset screen with proxy-prefix 

  configuration

- fixed initial sorting of repos inside repo group

- fixes issue when user tried to resubmit same permission into user/user_groups

- bumped beaker version that fixes #375 leap error bug

- fixed raw_changeset for git. It was generated with hg patch headers

- fixed vcs issue with last_changeset for filenodes

- fixed missing commit after hook delete

- fixed #372 issues with git operation detection that caused a security issue 

  for git repos

1.3.2 (**2012-02-28**)

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

news

++++

fixes

+++++

- fixed git protocol issues with repos-groups

- fixed git remote repos validator that prevented from cloning remote git repos

- fixes #370 ending slashes fixes for repo and groups

- fixes #368 improved git-protocol detection to handle other clients

            }

        stats = cur_stats if cur_stats else Statistics()

        stats.commit_activity = json.dumps(co_day_auth_aggr)

        stats.commit_activity_combined = json.dumps(overview_data)

        log.debug('last revison %s' % last_rev)

        leftovers = len(repo.revisions[last_rev:])

        log.debug('revisions to parse %s' % leftovers)

        if last_rev == 0 or leftovers < parse_limit:

            log.debug('getting code trending stats')

            stats.languages = json.dumps(__get_codes_stats(repo_name))

        try:

            stats.repository = dbrepo

            stats.stat_on_revision = last_cs.revision if last_cs else 0

            DBS.add(stats)

            DBS.commit()

        except:

            log.error(traceback.format_exc())

            DBS.rollback()

            lock.release()

            return False

        # final release

        lock.release()

        # execute another task if celery is enabled

        if len(repo.revisions) > 1 and CELERY_ON:

            run_task(get_commits_stats, repo_name, ts_min_y, ts_max_y)

        return True

    except LockHeld:

        log.info('LockHeld')

        return 'Task with key %s already running' % lockkey

@task(ignore_result=True)

@dbsession

def send_password_link(user_email):

    from rhodecode.model.notification import EmailNotificationModel

    log = get_logger(send_password_link)

    DBS = get_session()

    try:

        user = User.get_by_email(user_email)

        if user:

            log.debug('password reset user found %s' % user)

            link = url('reset_password_confirmation', key=user.api_key,

                       qualified=True)

            reg_type = EmailNotificationModel.TYPE_PASSWORD_RESET

            body = EmailNotificationModel().get_email_tmpl(reg_type,

                                                **{'user':user.short_contact,

                                                   'reset_url':link})

            log.debug('sending email')

            run_task(send_email, user_email,

                     _("password reset link"), body)

            log.info('send new password mail to %s' % user_email)

        else:

            log.debug("password reset email %s not found" % user_email)

    except:

        log.error(traceback.format_exc())

        return False

    return True

@task(ignore_result=True)

@dbsession

def reset_user_password(user_email):

    from rhodecode.lib import auth

    log = get_logger(reset_user_password)

    DBS = get_session()

    try:

        try:

            user = User.get_by_email(user_email)

            new_passwd = auth.PasswordGenerator().gen_password(8,

                             auth.PasswordGenerator.ALPHABETS_BIG_SMALL)

            if user:

                user.password = auth.get_crypt_password(new_passwd)

                user.api_key = auth.generate_api_key(user.username)

                DBS.add(user)

                DBS.commit()

                log.info('change password for %s' % user_email)

            if new_passwd is None:

                raise Exception('unable to generate new password')

        except:

            log.error(traceback.format_exc())

            DBS.rollback()

        run_task(send_email, user_email,

                 'Your new password',

                 'Your new RhodeCode password:%s' % (new_passwd))

        log.info('send new password mail to %s' % user_email)

    except:

        log.error('Failed to update user password')

        log.error(traceback.format_exc())

    return True

@task(ignore_result=True)

@dbsession

def send_email(recipients, subject, body, html_body=''):

    """

    Sends an email with defined parameters from the .ini files.

    :param recipients: list of recipients, it this is empty the defined email

        address from field 'email_to' is used instead

    :param subject: subject of the mail

    :param body: body of the mail

    :param html_body: html version of body

    """

    log = get_logger(send_email)

    DBS = get_session()

    email_config = config

    subject = "%s %s" % (email_config.get('email_prefix', ''), subject)

    if not recipients:

        # if recipients are not defined we send to email_config + all admins

        admins = [u.email for u in User.query()

                  .filter(User.admin == True).all()]

        recipients = [email_config.get('email_to')] + admins

    mail_from = email_config.get('app_email_from', 'RhodeCode')

    user = email_config.get('smtp_username')

    passwd = email_config.get('smtp_password')

    mail_server = email_config.get('smtp_server')

    mail_port = email_config.get('smtp_port')

    tls = str2bool(email_config.get('smtp_use_tls'))

    ssl = str2bool(email_config.get('smtp_use_ssl'))

    debug = str2bool(config.get('debug'))

    smtp_auth = email_config.get('smtp_auth')

    try:

        m = SmtpMailer(mail_from, user, passwd, mail_server, smtp_auth,

                       mail_port, ssl, tls, debug=debug)

        m.send(recipients, subject, body, html_body)

    except:

        log.error('Mail sending failed')

        log.error(traceback.format_exc())

        return False

    return True

@task(ignore_result=True)

@dbsession

def create_repo_fork(form_data, cur_user):

    """

    Creates a fork of repository using interval VCS methods

    :param form_data:

    :param cur_user:

    """

    from rhodecode.model.repo import RepoModel

    from rhodecode.model.user import UserModel

    log = get_logger(create_repo_fork)

    DBS = get_session()

    base_path = Repository.base_path()

    cur_user = UserModel(DBS)._get_user(cur_user)

    fork_name = form_data['repo_name_full']

    repo_type = form_data['repo_type']

    description = form_data['description']

    owner = cur_user

    private = form_data['private']

    clone_uri = form_data.get('clone_uri')

    repos_group = form_data['repo_group']

    landing_rev = form_data['landing_rev']

    copy_fork_permissions = form_data.get('copy_permissions')

    fork_of = RepoModel(DBS)._get_repo(form_data.get('fork_parent_id'))

    fork_repo = RepoModel(DBS).create_repo(

        fork_name, repo_type, description, owner, private, clone_uri,

        repos_group, landing_rev, just_db=True, fork_of=fork_of,

        copy_fork_permissions=copy_fork_permissions

    )

    update_after_clone = form_data['update_after_clone']

    source_repo_path = os.path.join(base_path, fork_of.repo_name)

    destination_fork_path = os.path.join(base_path, fork_name)

    log.info('creating fork of %s as %s', source_repo_path,

             destination_fork_path)

    backend = get_backend(repo_type)

    backend(safe_str(destination_fork_path), create=True,

            src_url=safe_str(source_repo_path),

    log_create_repository(fork_repo.get_dict(), created_by=cur_user.username)

    action_logger(cur_user, 'user_forked_repo:%s' % fork_name,

                   fork_of.repo_name, '', DBS)

    action_logger(cur_user, 'user_created_fork:%s' % fork_name,

                   fork_name, '', DBS)

    # finally commit at latest possible stage

    DBS.commit()

def __get_codes_stats(repo_name):

    from rhodecode.config.conf import  LANGUAGES_EXTENSIONS_MAP

    repo = Repository.get_by_repo_name(repo_name).scm_instance

    tip = repo.get_changeset()

    code_stats = {}

    def aggregate(cs):

        for f in cs[2]:

            ext = lower(f.extension)

            if ext in LANGUAGES_EXTENSIONS_MAP.keys() and not f.is_binary:

                if ext in code_stats:

                    code_stats[ext] += 1

                else:

                    code_stats[ext] = 1

    map(aggregate, tip.walk('/'))

    return code_stats or {}

# -*- coding: utf-8 -*-

"""

    vcs.backends.git

    ~~~~~~~~~~~~~~~~

    Git backend implementation.

    :created_on: Apr 8, 2010

    :copyright: (c) 2010-2011 by Marcin Kuzminski, Lukasz Balcerzak.

"""

import os

import re

import time

import posixpath

import logging

import traceback

import urllib

import urllib2

from dulwich.repo import Repo, NotGitRepository

#from dulwich.config import ConfigFile

from string import Template

from subprocess import Popen, PIPE

from rhodecode.lib.vcs.backends.base import BaseRepository

from rhodecode.lib.vcs.exceptions import BranchDoesNotExistError

from rhodecode.lib.vcs.exceptions import ChangesetDoesNotExistError

from rhodecode.lib.vcs.exceptions import EmptyRepositoryError

from rhodecode.lib.vcs.exceptions import RepositoryError

from rhodecode.lib.vcs.exceptions import TagAlreadyExistError

from rhodecode.lib.vcs.exceptions import TagDoesNotExistError

from rhodecode.lib.vcs.utils import safe_unicode, makedate, date_fromtimestamp

from rhodecode.lib.vcs.utils.lazy import LazyProperty

from rhodecode.lib.vcs.utils.ordered_dict import OrderedDict

from rhodecode.lib.vcs.utils.paths import abspath

from rhodecode.lib.vcs.utils.paths import get_user_home

from .workdir import GitWorkdir

from .changeset import GitChangeset

from .inmemory import GitInMemoryChangeset

from .config import ConfigFile

from rhodecode.lib import subprocessio

log = logging.getLogger(__name__)

class GitRepository(BaseRepository):

    """

    Git repository backend.

    """

    DEFAULT_BRANCH_NAME = 'master'

    scm = 'git'

    def __init__(self, repo_path, create=False, src_url=None,

                 update_after_clone=False, bare=False):

        self.path = abspath(repo_path)

        self._repo = self._get_repo(create, src_url, update_after_clone, bare)

        #temporary set that to now at later we will move it to constructor

        baseui = None

        if baseui is None:

            from mercurial.ui import ui

            baseui = ui()

        # patch the instance of GitRepo with an "FAKE" ui object to add

        # compatibility layer with Mercurial

        setattr(self._repo, 'ui', baseui)

        try:

            self.head = self._repo.head()

        except KeyError:

            self.head = None

        self._config_files = [

            bare and abspath(self.path, 'config') or abspath(self.path, '.git',

                'config'),

            abspath(get_user_home(), '.gitconfig'),

        ]

        self.bare = self._repo.bare

    @LazyProperty

    def revisions(self):

        """

        Returns list of revisions' ids, in ascending order.  Being lazy

        attribute allows external tools to inject shas from cache.

        """

        return self._get_all_revisions()

    def run_git_command(self, cmd):

        """

        Runs given ``cmd`` as git command and returns tuple

        (returncode, stdout, stderr).

        .. note::

           This method exists only until log/blame functionality is implemented

           at Dulwich (see https://bugs.launchpad.net/bugs/645142). Parsing

           os command's output is road to hell...

        :param cmd: git command to be executed

        """

        _copts = ['-c', 'core.quotepath=false', ]

        _str_cmd = False

        if isinstance(cmd, basestring):

            cmd = [cmd]

            _str_cmd = True

        gitenv = os.environ

        # need to clean fix GIT_DIR !

        if 'GIT_DIR' in gitenv:

            del gitenv['GIT_DIR']

        gitenv['GIT_CONFIG_NOGLOBAL'] = '1'

        cmd = ['git'] + _copts + cmd

        if _str_cmd:

            cmd = ' '.join(cmd)

        try:

            opts = dict(

                env=gitenv,

                shell=False,

            )

            if os.path.isdir(self.path):

                opts['cwd'] = self.path

            p = subprocessio.SubprocessIOChunker(cmd, **opts)

        except (EnvironmentError, OSError), err:

            log.error(traceback.format_exc())

            raise RepositoryError("Couldn't run git command (%s).\n"

                                  "Original error was:%s" % (cmd, err))

        return ''.join(p.output), ''.join(p.error)

    @classmethod

    def _check_url(cls, url):

        """

        Functon will check given url and try to verify if it's a valid

        link. Sometimes it may happened that mercurial will issue basic

        auth request that can cause whole API to hang when used from python

        or other external calls.

        On failures it'll raise urllib2.HTTPError

        """

        from mercurial.util import url as Url

        # those authnadlers are patched for python 2.6.5 bug an

        # infinit looping when given invalid resources

        from mercurial.url import httpbasicauthhandler, httpdigestauthhandler

        # check first if it's not an local url

        if os.path.isdir(url) or url.startswith('file:'):

            return True

        if('+' in url[:url.find('://')]):

            url = url[url.find('+') + 1:]

        handlers = []

        test_uri, authinfo = Url(url).authinfo()

        if not test_uri.endswith('info/refs'):

            test_uri = test_uri.rstrip('/') + '/info/refs'

        if authinfo:

            #create a password manager

            passmgr = urllib2.HTTPPasswordMgrWithDefaultRealm()

            passmgr.add_password(*authinfo)

            handlers.extend((httpbasicauthhandler(passmgr),

                             httpdigestauthhandler(passmgr)))

        o = urllib2.build_opener(*handlers)

        o.addheaders = [('User-Agent', 'git/1.7.8.0')]  # fake some git

        q = {"service": 'git-upload-pack'}

        qs = '?%s' % urllib.urlencode(q)

        cu = "%s%s" % (test_uri, qs)

        req = urllib2.Request(cu, None, {})

        try:

            resp = o.open(req)

            return resp.code == 200

        except Exception, e:

            # means it cannot be cloned

            raise urllib2.URLError("[%s] %s" % (url, e))

    def _get_repo(self, create, src_url=None, update_after_clone=False,

        if create and os.path.exists(self.path):

            raise RepositoryError("Location already exist")

        if src_url and not create:

            raise RepositoryError("Create should be set to True if src_url is "

                                  "given (clone operation creates repository)")

        try:

            if create and src_url:

                GitRepository._check_url(src_url)

                self.clone(src_url, update_after_clone, bare)

                return Repo(self.path)

            elif create:

                os.mkdir(self.path)

                if bare:

                    return Repo.init_bare(self.path)

                else:

                    return Repo.init(self.path)

            else:

                return Repo(self.path)

        except (NotGitRepository, OSError), err:

            raise RepositoryError(err)

    def _get_all_revisions(self):

        # we must check if this repo is not empty, since later command

        # fails if it is. And it's cheaper to ask than throw the subprocess

        # errors

        try:

            self._repo.head()

        except KeyError:

            return []

        cmd = 'rev-list --all --reverse --date-order'

        try:

            so, se = self.run_git_command(cmd)

        except RepositoryError:

            # Can be raised for empty repositories

            return []

        return so.splitlines()

    def _get_all_revisions2(self):

        #alternate implementation using dulwich

        includes = [x[1][0] for x in self._parsed_refs.iteritems()

                    if x[1][1] != 'T']

        return [c.commit.id for c in self._repo.get_walker(include=includes)]

    def _get_revision(self, revision):

        """

        For git backend we always return integer here. This way we ensure

        that changset's revision attribute would become integer.

        """

        pattern = re.compile(r'^[[0-9a-fA-F]{12}|[0-9a-fA-F]{40}]$')

        is_bstr = lambda o: isinstance(o, (str, unicode))

        is_null = lambda o: len(o) == revision.count('0')

        if len(self.revisions) == 0:

            raise EmptyRepositoryError("There are no changesets yet")

        if revision in (None, '', 'tip', 'HEAD', 'head', -1):

            revision = self.revisions[-1]

        if ((is_bstr(revision) and revision.isdigit() and len(revision) < 12)

            or isinstance(revision, int) or is_null(revision)):

            try:

                revision = self.revisions[int(revision)]

            except:

                raise ChangesetDoesNotExistError("Revision %r does not exist "

                    "for this repository %s" % (revision, self))

        elif is_bstr(revision):

            # get by branch/tag name

            _ref_revision = self._parsed_refs.get(revision)

            _tags_shas = self.tags.values()

            if _ref_revision:  # and _ref_revision[1] in ['H', 'RH', 'T']:

                return _ref_revision[0]

            # maybe it's a tag ? we don't have them in self.revisions

            elif revision in _tags_shas:

                return _tags_shas[_tags_shas.index(revision)]

            elif not pattern.match(revision) or revision not in self.revisions:

                raise ChangesetDoesNotExistError("Revision %r does not exist "

                    "for this repository %s" % (revision, self))

        # Ensure we return full id

        if not pattern.match(str(revision)):

            raise ChangesetDoesNotExistError("Given revision %r not recognized"

                % revision)

        return revision

    def _get_archives(self, archive_name='tip'):

        for i in [('zip', '.zip'), ('gz', '.tar.gz'), ('bz2', '.tar.bz2')]:

                yield {"type": i[0], "extension": i[1], "node": archive_name}

    def _get_url(self, url):

        """

        Returns normalized url. If schema is not given, would fall to

        filesystem (``file:///``) schema.

        """

        url = str(url)

        if url != 'default' and not '://' in url:

            url = ':///'.join(('file', url))

        return url

    @LazyProperty

    def name(self):

        return os.path.basename(self.path)

    @LazyProperty

    def last_change(self):

        """

        Returns last change made on this repository as datetime object

        """

        return date_fromtimestamp(self._get_mtime(), makedate()[1])

    def _get_mtime(self):

        try:

            return time.mktime(self.get_changeset().date.timetuple())

        except RepositoryError:

            idx_loc = '' if self.bare else '.git'

            # fallback to filesystem

            in_path = os.path.join(self.path, idx_loc, "index")

            he_path = os.path.join(self.path, idx_loc, "HEAD")

            if os.path.exists(in_path):

                return os.stat(in_path).st_mtime

            else:

                return os.stat(he_path).st_mtime

    @LazyProperty

    def description(self):

        idx_loc = '' if self.bare else '.git'

        undefined_description = u'unknown'

        description_path = os.path.join(self.path, idx_loc, 'description')

        if os.path.isfile(description_path):

            return safe_unicode(open(description_path).read())

        else:

            return undefined_description

    @LazyProperty

    def contact(self):

        undefined_contact = u'Unknown'

        return undefined_contact

    @property

    def branches(self):

        if not self.revisions:

            return {}

        sortkey = lambda ctx: ctx[0]

        _branches = [(x[0], x[1][0])

                     for x in self._parsed_refs.iteritems() if x[1][1] == 'H']

        return OrderedDict(sorted(_branches, key=sortkey, reverse=False))

    @LazyProperty

    def tags(self):

        return self._get_tags()

    def _get_tags(self):

        if not self.revisions:

            return {}

        sortkey = lambda ctx: ctx[0]

        _tags = [(x[0], x[1][0])

                 for x in self._parsed_refs.iteritems() if x[1][1] == 'T']

        return OrderedDict(sorted(_tags, key=sortkey, reverse=True))

    def tag(self, name, user, revision=None, message=None, date=None,

            **kwargs):

        """

        Creates and returns a tag for the given ``revision``.

        :param name: name for new tag

        :param user: full username, i.e.: "Joe Doe <joe.doe@example.com>"

        :param revision: changeset id for which new tag would be created

        :param message: message of the tag's commit

        :param date: date of tag's commit

        :raises TagAlreadyExistError: if tag with same name already exists

        """

        if name in self.tags:

            raise TagAlreadyExistError("Tag %s already exists" % name)

        changeset = self.get_changeset(revision)

        message = message or "Added tag %s for commit %s" % (name,

            changeset.raw_id)

        self._repo.refs["refs/tags/%s" % name] = changeset._commit.id

        self._parsed_refs = self._get_parsed_refs()

        self.tags = self._get_tags()

        return changeset

    def remove_tag(self, name, user, message=None, date=None):

        """

        Removes tag with the given ``name``.

        :param name: name of the tag to be removed