upstream/kallithea Commit - r43:2e1247e6

changed for pylons 0.1 / 1.0...

marcink -

r43:2e1247e6 default

parent child

pylons_app/controllers/admin.py

0 created 644 +87 0

@@ -0,0 +1,87 b''
	1	import logging
	2
	3	from pylons import request, response, session, tmpl_context as c, url, app_globals as g
	4	from pylons.controllers.util import abort, redirect
	5
	6	from pylons_app.lib.base import BaseController, render
	7	import os
	8	from mercurial import ui, hg
	9	from mercurial.error import RepoError
	10	from ConfigParser import ConfigParser
	11	log = logging.getLogger(__name__)
	12
	13	class AdminController(BaseController):
	14
	15
	16	def __before__(self):
	17	c.staticurl = g.statics
	18
	19	def index(self):
	20	# Return a rendered template
	21	return render('/admin.html')
	22
	23
	24	def manage_hgrc(self):
	25	pass
	26
	27	def hgrc(self, dirname):
	28	filename = os.path.join(dirname, '.hg', 'hgrc')
	29	return filename
	30
	31	def add_repo(self, new_repo):
	32
	33
	34	#extra check it can be add since it's the command
	35	if new_repo == 'add':
	36	c.msg = 'you basstard ! this repo is a command'
	37	c.new_repo = ''
	38	return render('add.html')
	39
	40	new_repo = new_repo.replace(" ", "_")
	41	new_repo = new_repo.replace("-", "_")
	42
	43	try:
	44	self._create_repo(new_repo)
	45	c.new_repo = new_repo
	46	c.msg = 'added repo'
	47	except Exception as e:
	48	c.new_repo = 'Exception when adding: %s' % new_repo
	49	c.msg = str(e)
	50
	51	return render('add.html')
	52
	53	def _check_repo(self, repo_name):
	54	p = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
	55	config_path = os.path.join(p, 'hgwebdir.config')
	56
	57	cp = ConfigParser()
	58
	59	cp.read(config_path)
	60	repos_path = cp.get('paths', '/').replace("**", '')
	61
	62	if not repos_path:
	63	raise Exception('Could not read config !')
	64
	65	self.repo_path = os.path.join(repos_path, repo_name)
	66
	67	try:
	68	r = hg.repository(ui.ui(), self.repo_path)
	69	hg.verify(r)
	70	#here we hnow that repo exists it was verified
	71	log.info('%s repo is already created', repo_name)
	72	raise Exception('Repo exists')
	73	except RepoError:
	74	log.info('%s repo is free for creation', repo_name)
	75	#it means that there is no valid repo there...
	76	return True
	77
	78
	79	def _create_repo(self, repo_name):
	80	if repo_name in [None, '', 'add']:
	81	raise Exception('undefined repo_name of repo')
	82
	83	if self._check_repo(repo_name):
	84	log.info('creating repo %s in %s', repo_name, self.repo_path)
	85	cmd = """mkdir %s && hg init %s""" \
	86	% (self.repo_path, self.repo_path)
	87	os.popen(cmd)

pylons_app/templates/admin.html

0 created 644 +51 0

@@ -0,0 +1,51 b''
	1	## -- coding: utf-8 --
	2	<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
	3	<html xmlns="http://www.w3.org/1999/xhtml">
	4	<head>
	5	<link rel="icon" href="${c.staticurl}hgicon.png" type="image/png" />
	6	<meta name="robots" content="index, nofollow"/>
	7	<link rel="stylesheet" href="${c.staticurl}style-monoblue.css" type="text/css" />
	8	<title>Mercurial repositories Admin</title>
	9	</head>
	10
	11	<body>
	12	<div id="container">
	13	<div class="page-header">
	14	<h1><a href="/">Home</a> / Admin</h1>
	15	<ul class="page-nav">
	16	</ul>
	17	</div>
	18	<table cellspacing="0">
	19	<tr>
	20	<td>${h.link_to(u'Create "ccc" repository',h.url('admin_add_repo',new_repo='ccc'))}</td>
	21	</tr>
	22	<tr>
	23	<td>${h.link_to(u'Create "ccc" repository',h.url('admin_add_repo',new_repo='ccc'))}</td>
	24	</tr>
	25	<tr>
	26	<td>${h.link_to(u'Create "ccc" repository',h.url('admin_add_repo',new_repo='ccc'))}</td>
	27	</tr>
	28	<tr>
	29	<td><h2>${c.new_repo}</h2></td>
	30	</tr>
	31	</table>
	32	<div class="page-footer">
	33	Mercurial Repository: admin
	34	</div>
	35
	36	<div id="powered-by">
	37	<p>
	38	<a href="http://mercurial.selenic.com/" title="Mercurial">
	39	<img src="${c.staticurl}hglogo.png" width="75" height="90" alt="mercurial"></a>
	40	</p>
	41	</div>
	42
	43	<div id="corner-top-left"></div>
	44	<div id="corner-top-right"></div>
	45	<div id="corner-bottom-left"></div>
	46	<div id="corner-bottom-right"></div>
	47
	48	</div>
	49	</body>
	50	</html>
	51	No newline at end of file

pylons_app/tests/functional/test_admin.py

0 created 644 +7 0

@@ -0,0 +1,7 b''
	1	from pylons_app.tests import *
	2
	3	class TestAdminController(TestController):
	4
	5	def test_index(self):
	6	response = self.app.get(url(controller='admin', action='index'))
	7	# Test response...

pylons_app/config/environment.py

0 +30 -5

             import os
             from mako.lookup import TemplateLookup
+            from pylons.configuration import PylonsConfig
             from pylons.error import handle_mako_error
-            from pylons import config
+            from sqlalchemy import engine_from_config
             import pylons_app.lib.app_globals as app_globals
             import pylons_app.lib.helpers
             from pylons_app.config.routing import make_map
+            from pylons_app.model import init_model
             log = logging.getLogger(__name__)
                 """Configure the Pylons environment via the ``pylons.config``
                 object
                 """
+                config = PylonsConfig()
                 # Pylons paths
                 root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
                 paths = dict(root=root,
                              templates=[os.path.join(root, 'templates')])
                 # Initialize config with the basic options
-                config.init_app(global_conf, app_conf, package='pylons_app',
+                config.init_app(global_conf, app_conf, package='pylons_app', paths=paths)
-                                template_engine='mako', paths=paths)
-                config['routes.map'] = make_map()
+                config['routes.map'] = make_map(config)
-                config['pylons.app_globals'] = app_globals.Globals()
+                config['pylons.app_globals'] = app_globals.Globals(config)
                 config['pylons.h'] = pylons_app.lib.helpers
+                # Setup cache object as early as possible
+                import pylons
+                pylons.cache._push_object(config['pylons.app_globals'].cache)
                 # Create the Mako TemplateLookup, with the default auto-escaping
                 config['pylons.app_globals'].mako_lookup = TemplateLookup(
                     directories=paths['templates'],
                     input_encoding='utf-8', default_filters=['escape'],
                     imports=['from webhelpers.html import escape'])
+                #sets the c attribute access when don't existing attribute ar accessed
+                config['pylons.strict_tmpl_context'] = False
+                #MULTIPLE DB configs
+                # Setup the SQLAlchemy database engine
+            #    if config['debug']:
+            #        #use query time debugging.
+            #        from pylons_app.lib.timer_proxy import TimerProxy
+            #        sa_engine_db1 = engine_from_config(config, 'sqlalchemy.db1.',
+            #                                                            proxy=TimerProxy())
+            #    else:
+            #        sa_engine_db1 = engine_from_config(config, 'sqlalchemy.db1.')
+                #init_model(sa_engine_db1)
                 # CONFIGURATION OPTIONS HERE (note: all config options will override
                 # any Pylons config options)
+                return config

pylons_app/config/middleware.py

0 +11 -9

             """Pylons middleware initialization"""
-            from beaker.middleware import CacheMiddleware, SessionMiddleware
+            from beaker.middleware import SessionMiddleware
             from paste.cascade import Cascade
             from paste.registry import RegistryManager
             from paste.urlparser import StaticURLParser
             from paste.deploy.converters import asbool
-            from pylons import config
             from pylons.middleware import ErrorHandler, StatusCodeRedirect
             from pylons.wsgiapp import PylonsApp
             from routes.middleware import RoutesMiddleware
             from pylons_app.config.environment import load_environment
             from pylons_app.lib.auth import authfunc
-            def make_app(global_conf, full_stack=True, **app_conf):
+            def make_app(global_conf, full_stack=True, static_files=True, **app_conf):
                 """Create a Pylons WSGI application and return it
                 ``global_conf``
                 """
                 # Configure the Pylons environment
-                load_environment(global_conf, app_conf)
+                config = load_environment(global_conf, app_conf)
                 # The Pylons WSGI app
-                app = PylonsApp()
+                app = PylonsApp(config=config)
                 # CUSTOM MIDDLEWARE HERE (filtered by error handling middlewares)
                 # Routing/Session/Cache Middleware
                 app = RoutesMiddleware(app, config['routes.map'])
                 app = SessionMiddleware(app, config)
-                app = CacheMiddleware(app, config)
                 app = AuthBasicHandler(app, config['repos_name'] + ' mercurial repository', authfunc)
                 if asbool(full_stack):
                     # 500 when debug is disabled)
                     if asbool(config['debug']):
                         #don't handle 404, since mercurial does it for us.
-                        app = StatusCodeRedirect(app, [400, 401, 403, 500])
+                        app = StatusCodeRedirect(app, [400, 401, 403])
                     else:
                         app = StatusCodeRedirect(app, [400, 401, 403, 500])
                 # Establish the Registry for this application
                 app = RegistryManager(app)
-                # Static files (If running in production, and Apache or another web
+                if asbool(static_files):
-                # server is handling this static content, remove the following 3 lines)
+                    # Serve static files
                     static_app = StaticURLParser(config['pylons.paths']['static_files'])
                     app = Cascade([static_app, app])
+                    app.config = config
                 return app

pylons_app/config/routing.py

0 +9 -7

             may take precedent over the more generic routes. For more information
             refer to the routes manual at http://routes.groovie.org/docs/
             """
-            from pylons import config
             from routes import Mapper
-            def make_map():
+            def make_map(config):
                 """Create, configure and return the routes Mapper"""
                 map = Mapper(directory=config['pylons.paths']['controllers'],
                              always_scan=config['debug'])
                 map.minimization = False
+                map.explicit = False
                 # The ErrorController route (handles 404/500 error pages); it should
                 # likely stay at the top, ensuring it can always be resolved
                 map.connect('/error/{action}/{id}', controller='error')
                 # CUSTOM ROUTES HERE
-                map.connect('hg_add', '/add/{new_repo:[a-z0-9\. _-]*}',
+                with map.submapper(path_prefix='/_admin', controller='admin') as m:
-                            controller = 'hg', action = 'add_repo')
+                    m.connect('admin_home', '/', action='index')#main page
-                map.connect('hg', '/{path_info:.*}',
+                    m.connect('admin_add_repo', '/add_repo/{new_repo:[a-z0-9\. _-]*}', action='add_repo')
-                            controller = 'hg', action = "view",
+                    m.connect('admin_manage_users', '/manage_users', action='index')
-                            path_info = '/')
+                map.connect('hg', '/{path_info:.*}', controller='hg',
+                            action="view", path_info='/')
                 return map

pylons_app/controllers/hg.py

0 +1 -94

@@ -1,14 +1,10 b''
1	#!/usr/bin/python	1	#!/usr/bin/python
2	# -- coding: utf-8 --	2	# -- coding: utf-8 --
3	import logging	3	import logging
4	import os	4	from pylons_app.lib.base import BaseController
5	from pylons_app.lib.base import BaseController, render
6	from pylons import tmpl_context as c, app_globals as g, session, request, config	5	from pylons import tmpl_context as c, app_globals as g, session, request, config
7	from pylons_app.lib import helpers as h	6	from pylons_app.lib import helpers as h
8	from mako.template import Template	7	from mako.template import Template
9	from mercurial import ui, hg
10	from mercurial.error import RepoError
11	from ConfigParser import ConfigParser
12	from pylons.controllers.util import abort	8	from pylons.controllers.util import abort
13		9
14	log = logging.getLogger(__name__)	10	log = logging.getLogger(__name__)
@@ -43,92 +39,3 b' class HgController(BaseController):'
43		39
44		40
45	return template.render(g=g, c=c, session=session, h=h)	41	return template.render(g=g, c=c, session=session, h=h)
46
47
48	def manage_hgrc(self):
49	pass
50
51	def hgrc(self, dirname):
52	filename = os.path.join(dirname, '.hg', 'hgrc')
53	return filename
54
55	def add_repo(self, new_repo):
56	c.staticurl = g.statics
57
58	#extra check it can be add since it's the command
59	if new_repo == 'add':
60	c.msg = 'you basstard ! this repo is a command'
61	c.new_repo = ''
62	return render('add.html')
63
64	new_repo = new_repo.replace(" ", "_")
65	new_repo = new_repo.replace("-", "_")
66
67	try:
68	self._create_repo(new_repo)
69	c.new_repo = new_repo
70	c.msg = 'added repo'
71	except Exception as e:
72	c.new_repo = 'Exception when adding: %s' % new_repo
73	c.msg = str(e)
74
75	return render('add.html')
76
77	def _check_repo(self, repo_name):
78	p = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
79	config_path = os.path.join(p, 'hgwebdir.config')
80
81	cp = ConfigParser()
82
83	cp.read(config_path)
84	repos_path = cp.get('paths', '/').replace("**", '')
85
86	if not repos_path:
87	raise Exception('Could not read config !')
88
89	self.repo_path = os.path.join(repos_path, repo_name)
90
91	try:
92	r = hg.repository(ui.ui(), self.repo_path)
93	hg.verify(r)
94	#here we hnow that repo exists it was verified
95	log.info('%s repo is already created', repo_name)
96	raise Exception('Repo exists')
97	except RepoError:
98	log.info('%s repo is free for creation', repo_name)
99	#it means that there is no valid repo there...
100	return True
101
102
103	def _create_repo(self, repo_name):
104	if repo_name in [None, '', 'add']:
105	raise Exception('undefined repo_name of repo')
106
107	if self._check_repo(repo_name):
108	log.info('creating repo %s in %s', repo_name, self.repo_path)
109	cmd = """mkdir %s && hg init %s""" \
110	% (self.repo_path, self.repo_path)
111	os.popen(cmd)
112
113	#def _make_app():
114	# #for single a repo
115	# #return hgweb("/path/to/repo", "Name")
116	# repos = "hgwebdir.config"
117	# return hgwebdir(repos)
118	#
119
120	# def view(self, environ, start_response):
121	# #the following is only needed when using hgwebdir
122	# app = _make_app()
123	# #return wsgi_app(environ, start_response)
124	# response = app(request.environ, self.start_response)
125	#
126	# if environ['PATH_INFO'].find("static") != -1:
127	# return response
128	# else:
129	# #wrap the murcurial response in a mako template.
130	# template = Template("".join(response),
131	# lookup = environ['pylons.pylons']\
132	# .config['pylons.g'].mako_lookup)
133	#
134	# return template.render(g = g, c = c, session = session, h = h)

pylons_app/lib/app_globals.py

0 +5 -1

             from mercurial.hgweb.request import wsgiapplication
             from mercurial import ui, config
             import os
+            from beaker.cache import CacheManager
+            from beaker.util import parse_cache_config_options
             class Globals(object):
                 """Globals acts as a container for objects available throughout the
                 """
-                def __init__(self):
+                def __init__(self, config):
                     """One instance of Globals is created during application
                     initialization and is available during requests via the
                     'app_globals' variable
                     #two ways of building the merc app i don't know
                     #the fastest one but belive the wsgiapp is better
                     #self.hgapp = self.make_web_app()
+                    self.cache = CacheManager(**parse_cache_config_options(config))
                     self.hgapp = wsgiapplication(self.make_web_app)

pylons_app/lib/helpers.py

0 +3 -4

             Consists of functions to typically be used within templates, but also
             available to Controllers. This module is available to both as 'h'.
             """
-            from routes import redirect_to, url_for
+            from pylons import url
             from webhelpers.html import (literal, HTML, escape)
             from webhelpers.html.tools import (auto_link, button_to, highlight, js_obfuscate
                                                , mail_to, strip_links, strip_tags, tag_re)
                 @param url: the url for link
                 '''
-                def __call__(self, label = '', *url, **urlargs):
+                def __call__(self, label='', *url_, **urlargs):
                     if label is None or '':
                         label = url
-                    link_fn = link_to(label, url_for(*url, **urlargs))
+                    link_fn = link_to(label, url(*url_, **urlargs))
                     return link_fn

pylons_app/templates/monoblue_custom/notfound.tmpl

0 +4 -1

                 <h2 class="no-link no-border">Not Found</h2>
                 <p class="normal">The specified repository "{repo|escape}" is unknown, sorry.</p>
-                <p class="normal"><a href="/add/{repo|escape}">Create "{repo|escape}" repository </a></p>
+                <p class="normal">
+                <a href="/_admin/add_repo/{repo|escape}">Create "{repo|escape}" repository</a>
+                </p>
                 <p class="normal">Go back to the <a href="{url}">main repository list page</a>.</p>
                 <div class="page-footer">
                     <p>Mercurial Repository: {repo|escape}</p>

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages