if not os.path.isfile(path):

            log.warning('Unable to read config file %s' % path)

            return False

        log.debug('reading hgrc from %s', path)

        cfg = config.config()

        cfg.read(path)

        for section in ui_sections:

            for k, v in cfg.items(section):

                baseui.setconfig(section, k, v)

                log.debug('settings ui from file[%s]%s:%s', section, k, v)

    elif read_from == 'db':

        hg_ui = get_hg_ui_cached()

        for ui_ in hg_ui:

            if ui_.ui_active:

                log.debug('settings ui from db[%s]%s:%s', ui_.ui_section, ui_.ui_key, ui_.ui_value)

                baseui.setconfig(ui_.ui_section, ui_.ui_key, ui_.ui_value)

    return baseui

def set_rhodecode_config(config):

    hgsettings = get_hg_settings()

    for k, v in hgsettings.items():

        config[k] = v

def invalidate_cache(name, *args):

    """Invalidates given name cache"""

    from beaker.cache import region_invalidate

    log.info('INVALIDATING CACHE FOR %s', name)

    """propagate our arguments to make sure invalidation works. First

    argument has to be the name of cached func name give to cache decorator

    without that the invalidation would not work"""

    tmp = [name]

    tmp.extend(args)

    args = tuple(tmp)

    if name == 'cached_repo_list':

        from rhodecode.model.hg import _get_repos_cached

        region_invalidate(_get_repos_cached, None, *args)

    if name == 'full_changelog':

        from rhodecode.model.hg import _full_changelog_cached

        region_invalidate(_full_changelog_cached, None, *args)

class EmptyChangeset(BaseChangeset):

    """

    An dummy empty changeset. It's possible to pass hash when creating

    an EmptyChangeset

    """

    def __init__(self, cs='0' * 40):

        self._empty_cs = cs

        self.revision = -1

        self.message = ''

        self.author = ''

        self.date = ''

    @LazyProperty

    def raw_id(self):

        """

        Returns raw string identifying this changeset, useful for web

        representation.

        """

        return self._empty_cs

    @LazyProperty

    def short_id(self):

        return self.raw_id[:12]

    def get_file_changeset(self, path):

        return self

    def get_file_content(self, path):

        return u''

    def get_file_size(self, path):

        return 0

def repo2db_mapper(initial_repo_list, remove_obsolete=False):

    """

    maps all found repositories into db

    """

    sa = meta.Session()

    rm = RepoModel(sa)

    user = sa.query(User).filter(User.admin == True).first()

    for name, repo in initial_repo_list.items():

        if not rm.get(name, cache=False):

            log.info('repository %s not found creating default', name)

            form_data = {

                         'repo_name':name,

                         'description':repo.description if repo.description != 'unknown' else \

                                        'auto description for %s' % name,

                         'private':False

                         }

            rm.create(form_data, user, just_db=True)

    if remove_obsolete:

        #remove from database those repositories that are not in the filesystem

        for repo in sa.query(Repository).all():

            if repo.repo_name not in initial_repo_list.keys():

                sa.delete(repo)

                sa.commit()

    meta.Session.remove()

class OrderedDict(dict, DictMixin):

    def __init__(self, *args, **kwds):

        if len(args) > 1:

            raise TypeError('expected at most 1 arguments, got %d' % len(args))

        try:

            self.__end

        except AttributeError:

            self.clear()

        self.update(*args, **kwds)

    def clear(self):

        self.__end = end = []

        end += [None, end, end]         # sentinel node for doubly linked list

        self.__map = {}                 # key --> [key, prev, next]

        dict.clear(self)

    def __setitem__(self, key, value):

        if key not in self:

            end = self.__end

            curr = end[1]

            curr[2] = end[1] = self.__map[key] = [key, curr, end]

        dict.__setitem__(self, key, value)

    def __delitem__(self, key):

        dict.__delitem__(self, key)

        key, prev, next = self.__map.pop(key)

        prev[2] = next

        next[1] = prev

    def __iter__(self):

        end = self.__end

        curr = end[2]

        while curr is not end:

            yield curr[0]

            curr = curr[2]

    def __reversed__(self):

        end = self.__end

        curr = end[1]

        while curr is not end:

            yield curr[0]

            curr = curr[1]

    def popitem(self, last=True):

        if not self:

            raise KeyError('dictionary is empty')

        if last:

            key = reversed(self).next()

        else:

            key = iter(self).next()

        value = self.pop(key)

        return key, value

    def __reduce__(self):

        items = [[k, self[k]] for k in self]

        tmp = self.__map, self.__end

        del self.__map, self.__end

        inst_dict = vars(self).copy()

        self.__map, self.__end = tmp

        if inst_dict:

            return (self.__class__, (items,), inst_dict)

        return self.__class__, (items,)

    def keys(self):

        return list(self)

    setdefault = DictMixin.setdefault

    update = DictMixin.update

    pop = DictMixin.pop

    values = DictMixin.values

    items = DictMixin.items

    iterkeys = DictMixin.iterkeys

    itervalues = DictMixin.itervalues

    iteritems = DictMixin.iteritems

    def __repr__(self):

        if not self:

# MA  02110-1301, USA.

"""

Created on Jun 5, 2010

model for handling repositories actions

:author: marcink

"""

from datetime import datetime

from pylons import app_globals as g

from rhodecode.model.db import Repository, RepoToPerm, User, Permission

from rhodecode.model.meta import Session

from rhodecode.model.user import UserModel

from rhodecode.model.caching_query import FromCache

import logging

import os

import shutil

import traceback

log = logging.getLogger(__name__)

class RepoModel(object):

    def __init__(self, sa=None):

        if not sa:

            self.sa = Session()

        else:

            self.sa = sa

    def get(self, repo_id, cache=False):

        repo = self.sa.query(Repository)\

            .filter(Repository.repo_name == repo_id)

        if cache:

            repo = repo.options(FromCache("sql_cache_short",

                                          "get_repo_%s" % repo))

        return repo.scalar()

    def get_users_js(self):

        users = self.sa.query(User).filter(User.active == True).all()

        u_tmpl = '''{id:%s, fname:"%s", lname:"%s", nname:"%s"},'''

        users_array = '[%s];' % '\n'.join([u_tmpl % (u.user_id, u.name,

                                                    u.lastname, u.username)

                                        for u in users])

        return users_array

    def update(self, repo_name, form_data):

        try:

            #update permissions

            for username, perm in form_data['perms_updates']:

                r2p = self.sa.query(RepoToPerm)\

                        .filter(RepoToPerm.user == UserModel(self.sa).get_by_username(username, cache=False))\

                        .filter(RepoToPerm.repository == self.get(repo_name))\

                        .one()

                r2p.permission_id = self.sa.query(Permission).filter(

                                                Permission.permission_name ==

                                                perm).one().permission_id

                self.sa.add(r2p)

            #set new permissions

            for username, perm in form_data['perms_new']:

                r2p = RepoToPerm()

                r2p.repository = self.get(repo_name)

                r2p.user = UserModel(self.sa).get_by_username(username, cache=False)

                r2p.permission_id = self.sa.query(Permission).filter(

                                        Permission.permission_name == perm)\

                                        .one().permission_id

                self.sa.add(r2p)

            #update current repo

            cur_repo = self.get(repo_name, cache=False)

            for k, v in form_data.items():

                if k == 'user':

                    cur_repo.user_id = v

                else:

                    setattr(cur_repo, k, v)

            self.sa.add(cur_repo)

            if repo_name != form_data['repo_name']:

                #rename our data

                self.__rename_repo(repo_name, form_data['repo_name'])

            self.sa.commit()

        except:

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise

    def create(self, form_data, cur_user, just_db=False, fork=False):

        try:

            if fork:

                repo_name = str(form_data['fork_name'])

                org_name = str(form_data['repo_name'])

            else:

                org_name = repo_name = str(form_data['repo_name'])

            new_repo = Repository()

            for k, v in form_data.items():

                if k == 'repo_name':

                    v = repo_name

                setattr(new_repo, k, v)

            if fork:

                parent_repo = self.sa.query(Repository)\

                        .filter(Repository.repo_name == org_name).scalar()

                new_repo.fork = parent_repo

            new_repo.user_id = cur_user.user_id

            self.sa.add(new_repo)

            #create default permission

            repo_to_perm = RepoToPerm()

            default = 'repository.read'

            for p in UserModel(self.sa).get_by_username('default', cache=False).user_perms:

                if p.permission.permission_name.startswith('repository.'):

                    default = p.permission.permission_name

                    break

            default_perm = 'repository.none' if form_data['private'] else default

            repo_to_perm.permission_id = self.sa.query(Permission)\

                    .filter(Permission.permission_name == default_perm)\

                    .one().permission_id

            repo_to_perm.repository_id = new_repo.repo_id

            repo_to_perm.user_id = UserModel(self.sa).get_by_username('default', cache=False).user_id

            self.sa.add(repo_to_perm)

            self.sa.commit()

            if not just_db:

                self.__create_repo(repo_name)

        except:

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise

    def create_fork(self, form_data, cur_user):

        from rhodecode.lib.celerylib import tasks, run_task

        run_task(tasks.create_repo_fork, form_data, cur_user)

    def delete(self, repo):

        try:

            self.sa.delete(repo)

            self.sa.commit()

            self.__delete_repo(repo.repo_name)

        except:

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise

    def delete_perm_user(self, form_data, repo_name):

        try:

            self.sa.query(RepoToPerm)\

                .filter(RepoToPerm.repository == self.get(repo_name))\

                .filter(RepoToPerm.user_id == form_data['user_id']).delete()

            self.sa.commit()

        except:

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise

    def __create_repo(self, repo_name):

        from rhodecode.lib.utils import check_repo

        repo_path = os.path.join(g.base_path, repo_name)

        if check_repo(repo_name, g.base_path):

            log.info('creating repo %s in %s', repo_name, repo_path)

            from vcs.backends.hg import MercurialRepository

            MercurialRepository(repo_path, create=True)

    def __rename_repo(self, old, new):

        log.info('renaming repo from %s to %s', old, new)

        old_path = os.path.join(g.base_path, old)

        new_path = os.path.join(g.base_path, new)

        if os.path.isdir(new_path):

            raise Exception('Was trying to rename to already existing dir %s',

                            new_path)

        shutil.move(old_path, new_path)

    def __delete_repo(self, name):

        rm_path = os.path.join(g.base_path, name)

        log.info("Removing %s", rm_path)

        #disable hg 

        shutil.move(os.path.join(rm_path, '.hg'), os.path.join(rm_path, 'rm__.hg'))

        #disable repo

        shutil.move(rm_path, os.path.join(g.base_path, 'rm__%s__%s' \

                                          % (datetime.today(), name)))

height:16px;

padding-left:20px;

margin-top:7px;

text-align:left;

}

.cs_files .cs_changed {

background:url("../images/icons/page_white_edit.png") no-repeat scroll 3px;

height:16px;

padding-left:20px;

margin-top:7px;

text-align:left;

}

.cs_files .cs_removed {

background:url("../images/icons/page_white_delete.png") no-repeat scroll 3px;

height:16px;

padding-left:20px;

margin-top:7px;

text-align:left;

}

#graph {

overflow:hidden;

}

#graph_nodes {

width:160px;

float:left;

margin-left:-50px;

margin-top:5px;

}

#graph_content {

width:800px;

float:left;

}

#graph_content .container_header {

border:1px solid #CCC;

padding:10px;

}

#graph_content .container {

border-bottom:1px solid #CCC;

border-left:1px solid #CCC;

border-right:1px solid #CCC;

min-height:80px;

overflow:hidden;

font-size:1.2em;

}

#graph_content .container .right {

float:right;

width:28%;

text-align:right;

padding-bottom:5px;

}

#graph_content .container .left .date {

font-weight:700;

padding-bottom:5px;

}

#graph_content .container .left .message {

font-size:100%;

padding-top:3px;

white-space:pre-wrap;

}

.right div {

clear:both;

}

.right .changes .added,.changed,.removed {

border:1px solid #DDD;

display:block;

float:right;

text-align:center;

min-width:15px;

}

.right .changes .added {

background:#BFB;

}

.right .changes .changed {

background:#FD8;

}

.right .changes .removed {

background:#F88;

}

.right .merge {

vertical-align:top;

font-weight:700;

}

.right .parent {

font-size:90%;

font-family:monospace;

}

.right .logtags .branchtag {

background:#FFF url("../images/icons/arrow_branch.png") no-repeat right 6px;

display:block;

}

.right .logtags .tagtag {

background:#FFF url("../images/icons/tag_blue.png") no-repeat right 6px;

display:block;

}

div.browserblock {

overflow:hidden;

border:1px solid #ccc;

background:#f8f8f8;

font-size:100%;

line-height:125%;

padding:0;

}

div.browserblock .browser-header {

border-bottom:1px solid #CCC;

background:#FFF;

color:blue;

padding:10px 0;

}

div.browserblock .browser-header span {

margin-left:25px;

font-weight:700;

}

div.browserblock .browser-body {

background:#EEE;

}

table.code-browser {

border-collapse:collapse;

width:100%;

}

table.code-browser tr {

margin:3px;

}

table.code-browser thead th {

background-color:#EEE;

height:20px;

font-size:1.1em;

font-weight:700;

text-align:left;

padding-left:10px;

}

table.code-browser tbody td {

padding-left:10px;

height:20px;

}

table.code-browser .browser-file {

background:url("../images/icons/document_16.png") no-repeat scroll 3px;

height:16px;

padding-left:20px;

text-align:left;

}

table.code-browser .browser-dir {

background:url("../images/icons/folder_16.png") no-repeat scroll 3px;

height:16px;

padding-left:20px;

text-align:left;

}

.box .search {

clear:both;

overflow:hidden;

margin:0;

padding:0 20px 10px;

}

.box .search div.search_path {

background:none repeat scroll 0 0 #EEE;

border:1px solid #CCC;

color:blue;

margin-bottom:10px;

padding:10px 0;

}

.box .search div.search_path div.link {

font-weight:700;

margin-left:25px;

}

.box .search div.search_path div.link a {

color:#003367;

cursor:pointer;

text-decoration:none;

}

#path_unlock {

color:red;

font-size:1.2em;

padding-left:4px;

}

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

<%inherit file="/base/base.html"/>

<%def name="title()">

${c.repo_name} ${_('Changelog')} - ${c.rhodecode_name}

</%def>

<%def name="breadcrumbs_links()">

    ${h.link_to(u'Home',h.url('/'))}

    »

    ${h.link_to(c.repo_name,h.url('summary_home',repo_name=c.repo_name))}

    »

    ${_('Changelog')} - ${_('showing ')} ${c.size if c.size <= c.total_cs else c.total_cs} ${_('out of')} ${c.total_cs} ${_('revisions')}  

</%def>

<%def name="page_nav()">

	${self.menu('changelog')}     

</%def>

<%def name="main()">

<div class="box">

    <!-- box / title -->

    <div class="title">

        ${self.breadcrumbs()}

    </div>

    <div class="table">

		% if c.pagination:

			<div id="graph">

				<div id="graph_nodes">

					<canvas id="graph_canvas"></canvas>

				</div>

				<div id="graph_content">

					<div class="container_header">

        ${h.form(h.url.current(),method='get')}

        <div class="info_box">

          <span>${_('Show')}:</span>

          ${h.text('size',size=1,value=c.size)}

          <span>${_('revisions')}</span>

          ${h.submit('set',_('set'))}

        </div>

        ${h.end_form()}

					</div>

				%for cnt,cs in enumerate(c.pagination):

					<div id="chg_${cnt+1}" class="container">

						<div class="left">

							<div class="date">${_('commit')} ${cs.revision}: ${h.short_id(cs.raw_id)}@${cs.date}</div>

							<div class="author">

								<div class="gravatar">

									<img alt="gravatar" src="${h.gravatar_url(h.email(cs.author),20)}"/>

								</div>

								<span>${h.person(cs.author)}</span><br/>

								<span><a href="mailto:${h.email_or_none(cs.author)}">${h.email_or_none(cs.author)}</a></span><br/>

							</div>

							<div class="message">${h.link_to(h.wrap_paragraphs(cs.message),h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id))}</div>

						</div>	

						<div class="right">

									<div class="changes">

									</div>					

										%if len(cs.parents)>1:

										<div class="merge">

											${_('merge')}<img alt="merge" src="/images/icons/arrow_join.png"/>

										</div>

										%endif

								   %if cs.parents:							

									%for p_cs in reversed(cs.parents):

										<div class="parent">${_('Parent')} ${p_cs.revision}: ${h.link_to(h.short_id(p_cs.raw_id),

											h.url('changeset_home',repo_name=c.repo_name,revision=p_cs.raw_id),title=p_cs.message)}

										</div>

									%endfor

								   %else:	

                                        <div class="parent">${_('No parents')}</div>   

                                   %endif  

								<span class="logtags">

									<span class="branchtag" title="${'%s %s' % (_('branch'),cs.branch)}">

									${h.link_to(cs.branch,h.url('files_home',repo_name=c.repo_name,revision=cs.raw_id))}</span>

									%for tag in cs.tags:

										<span class="tagtag"  title="${'%s %s' % (_('tag'),tag)}">

										${h.link_to(tag,h.url('files_home',repo_name=c.repo_name,revision=cs.raw_id))}</span>

									%endfor

								</span>																	

						</div>				

					</div>

				%endfor

				<div class="pagination-wh pagination-left">

					${c.pagination.pager('$link_previous ~2~ $link_next')}

				</div>			

				</div>

			</div>

			<script type="text/javascript" src="/js/graph.js"></script>

			<script type="text/javascript">

				YAHOO.util.Event.onDOMReady(function(){

					function set_canvas() {

						var c = document.getElementById('graph_nodes');

						var t = document.getElementById('graph_content');

						canvas = document.getElementById('graph_canvas');

						var div_h = t.clientHeight;

						c.style.height=div_h+'px';

						canvas.setAttribute('height',div_h);

						canvas.setAttribute('width',160);

					};

					set_canvas();

					var jsdata = ${c.jsdata|n};

					var r = new BranchRenderer();

					r.render(jsdata); 

				});

			</script>

		%else:

			${_('There are no changes yet')}

		%endif  

    </div>

</div>    

</%def>