~loggerhead-team/loggerhead/trunk-rich

« back to all changes in this revision

Viewing changes to loggerhead/controllers/__init__.py

MergeĀ fromĀ trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
15
15
# You should have received a copy of the GNU General Public License
16
16
# along with this program; if not, write to the Free Software
17
17
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
 
#
19
 
 
20
 
import logging
21
 
import os
22
 
import re
23
 
 
24
 
import turbogears
25
 
from turbogears import controllers
26
 
from configobj import ConfigObj
 
18
 
 
19
import time
 
20
 
 
21
from paste.request import path_info_pop
27
22
 
28
23
from loggerhead import util
29
 
from loggerhead.branchview import BranchView
30
 
from loggerhead.history import is_branch
31
24
from loggerhead.templatefunctions import templatefunctions
32
 
 
33
 
log = logging.getLogger("loggerhead.controllers")
34
 
 
35
 
 
36
 
def cherrypy_friendly(s):
37
 
    """
38
 
    convert a config section name into a name that pleases cherrypy.
39
 
    """
40
 
    return re.sub(r'[^\w\d_]', '_', s)
41
 
 
42
 
 
43
 
class Project (object):
44
 
    def __init__(self, name, config, root_config):
45
 
        self.name = name
46
 
        self.friendly_name = config.get('name', name)
47
 
        self.description = config.get('description', '')
48
 
        self.long_description = config.get('long_description', '')
49
 
        self._config = config
50
 
        self._root_config = root_config
51
 
        
52
 
        self._views = []
53
 
        for view_name in config.sections:
54
 
            log.debug('Configuring (project %s) branch %s...', name, view_name)
55
 
            self._add_view(view_name, config[view_name], config[view_name].get('folder'))
56
 
        
57
 
        self._auto_folder = config.get('auto_publish_folder', None)
58
 
        self._auto_list = []
59
 
        if self._auto_folder is not None:
60
 
            self._recheck_auto_folders()
61
 
    
62
 
    def _recheck_auto_folders(self):
63
 
        if self._auto_folder is None:
64
 
            return
65
 
        auto_list = []
66
 
        # scan a folder for bazaar branches, and add them automatically
67
 
        for path, folders, filenames in os.walk(self._auto_folder):
68
 
            for folder in folders:
69
 
                folder = os.path.join(path, folder)
70
 
                if is_branch(folder):
71
 
                    auto_list.append(folder)
72
 
        auto_list.sort()
73
 
        if auto_list == self._auto_list:
74
 
            # nothing has changed; do nothing.
75
 
            return
76
 
 
77
 
        # rebuild views:
78
 
        log.debug('Rescanning auto-folder for project %s ...', self.name)
79
 
        self._views = []
80
 
        for folder in auto_list:
81
 
            view_name = os.path.basename(folder)
82
 
            log.debug('Auto-configuring (project %s) branch %s...', self.name, view_name)
83
 
            self._add_view(view_name, ConfigObj(), folder)
84
 
        self._auto_list = auto_list
85
 
        
86
 
    def _add_view(self, view_name, view_config, folder):
87
 
        c_view_name = cherrypy_friendly(view_name)
88
 
        view = BranchView(
89
 
            self.name, c_view_name, view_name, folder, view_config,
90
 
            self._config, self._root_config)
91
 
        self._views.append(view)
92
 
        setattr(self, c_view_name, view)
93
 
        
94
 
    views = property(lambda self: self._views)
95
 
 
96
 
 
97
 
class Root (controllers.RootController):
98
 
    def __init__(self, config):
99
 
        self._projects = []
100
 
        self._config = config
101
 
        for project_name in self._config.sections:
102
 
            c_project_name = cherrypy_friendly(project_name)
103
 
            project = Project(
104
 
                c_project_name, self._config[project_name], self._config)
105
 
            self._projects.append(project)
106
 
            setattr(self, c_project_name, project)
107
 
        
108
 
    @turbogears.expose(template='zpt:loggerhead.templates.browse')
109
 
    def index(self):
110
 
        for p in self._projects:
111
 
            p._recheck_auto_folders()
112
 
        vals = {
113
 
            'projects': self._projects,
114
 
            'util': util,
115
 
            'title': self._config.get('title', None),
116
 
        }
117
 
        vals.update(templatefunctions)
118
 
        return vals
119
 
 
120
 
 
121
 
# for use in profiling the very-slow get_change() method:
122
 
#h = Root.bazaar.bzr_dev.get_history()
123
 
#w = list(h.get_revision_history())
124
 
#h._get_changes_profiled(w[:100])
125
 
 
 
25
from loggerhead.zptsupport import load_template
 
26
 
 
27
class TemplatedBranchView(object):
 
28
 
 
29
    template_path = None
 
30
 
 
31
    def __init__(self, branch):
 
32
        self._branch = branch
 
33
        self.log = branch.log
 
34
 
 
35
    def default(self, request, response):
 
36
        z = time.time()
 
37
        h = self._branch.history
 
38
        kw = request.GET
 
39
        util.set_context(kw)
 
40
 
 
41
        h._branch.lock_read()
 
42
        try:
 
43
            args = []
 
44
            while 1:
 
45
                arg = path_info_pop(request.environ)
 
46
                if arg is None:
 
47
                    break
 
48
                args.append(arg)
 
49
 
 
50
            vals = {
 
51
                'branch': self._branch,
 
52
                'util': util,
 
53
                'history': h,
 
54
                'url': self._branch.context_url,
 
55
            }
 
56
            vals.update(templatefunctions)
 
57
            del response.headers['Content-Type']
 
58
            vals.update(self.get_values(h, args, kw, response))
 
59
 
 
60
            self.log.info('/%s: %r secs' % (
 
61
                self.__class__.__name__, time.time() - z,))
 
62
            if 'Content-Type' not in response.headers:
 
63
                response.headers['Content-Type'] = 'text/html'
 
64
            template = load_template(self.template_path)
 
65
            template.expand_into(response, **vals)
 
66
        finally:
 
67
            h._branch.unlock()