Produits Entr'ouvert » Larpe

- interface d'admin, permettant de d?finir les points ci-dessus, (?criture d'un fichier inclus dans la conf apache puis reload)

- options possibles par serveur vhost/r?pertoire

  - [x] acc?s n?cessitant authentification (?a, ?a ferait un ?quivalent LemonLDAP)

- possibilit? interception URL /login

  - pour en faire libertysation:

    - redirect, ...

    - page proposant d'?tablir la f?d?ration, o? l'utilisateur entre identifiant / mot de passe du SP

Fait

====

- rp par vhost (appli1.example.com, rp de appli1.interne)

- rp par repertoire (www.example.com/appli1, rp de appl1.interne)

from quixote.server.scgi_server import run

from quixote.publish import Publisher

from quixote import enable_ptl

import quixote

enable_ptl()

from root import RootDirectory

def create_publisher():

	return Publisher(RootDirectory())

#quixote.DEFAULT_CHARSET = 'utf-8'

run(create_publisher, port=3003, script_name = '')

from quixote.directory import Directory

from template import generate_html

from apache_edit import ApacheEdit

from apache_form import ApacheForm

from apache_vhost import ApacheVhost

class Apache(Directory):

	"""

	Apache administration directory

	"""

	_q_exports = ['', 'new', 'edit']

	edit = ApacheEdit()

	def _q_index [html] (self):

		#form = ApacheForm()

		body = '<a href="new">Cr?er un nouvel h?te virtuel</a>'

		generate_html('apache', body)

		#generate_html('apache', self.generate_body())

#	def _q_lookup [html] (self, component):

#		vhost = ApacheVhost(component)

#		vhost._q_lookup(component)

#		return component

	def new [html] (self):

		form = ApacheForm()

		generate_html('apache', form.handle())

from quixote.directory import Directory

from template import generate_html

from apache_form import ApacheForm

class ApacheEdit(Directory):

	"""

	Apache administration directory

	"""

	_q_exports = ['']

	def _q_index [html] (self):

		"""Error"""

		return

	def _q_lookup [html] (self, server_name):

		form = ApacheForm(server_name)

		generate_html('apache', form.handle())

import os

from quixote.publish import get_response

from quixote.form import Form, StringWidget, PasswordWidget, \

     RadiobuttonsWidget, SingleSelectWidget, MultipleSelectWidget, \

     CheckboxWidget, FileWidget

class ApacheForm(Form):

	def __init__(self, server_name = None):

		Form.__init__(self)

		#get_response().set_charset('utf-8')

		self.server_name = server_name

	def handle(self):

		if (self.server_name is None):

			self.add_string(name = 'proxy_name', title = 'Nom du serveur proxy', required = True)

		else:

			self.add_string(name = 'proxy_name', title = 'Nom du serveur proxy', value = self.server_name, required = True)

		self.add_string(name = 'proxy_ip', title = 'Adresse IP du serveur proxy', required = True)

		self.add_string(name = 'proxy_port', title = 'Port du serveur proxy', value = '80', required = True)

		#self.add_string(name = 'proxy_admin', title = 'Administrateur du serveur proxy', required = False)

		self.add_string(name = 'site_address', title = 'Adresse du site', value = 'http://', required = True)

		self.add_string(name = 'proxy_directory', title = 'R?pertoire du proxy', value = '/', required = True)

		self.add_submit('submit')

		if not self.is_submitted() or self.has_errors():

			return self.render()

		return self.success()

	def success [html] (self):

		values = {}

		#get_response().set_charset('utf-8')

		for widget in self.get_all_widgets():

			values[widget.get_name()] = widget.parse()

			#"""<p>name : """

			#name

			#"""</p><p>value : """

			#repr(value)

			#"""</p>"""

		try:

			self.write_apache_conf(values)

			#self.write_apache_conf(values['proxy_name'],

			#						values['proxy_ip'],

			#						values['proxy_port'],

			#						values['site_address'],

			#						values['proxy_directory'])

		except IOError:

			"""Failed writing apache configuration"""

		else:

			"""Apache configuration written"""

	#def write_apache_conf(self, proxy_name, proxy_ip, proxy_port, site_address, proxy_directory):

	def write_apache_conf(self, values):

		"""Caller must catch IOError exceptions"""

		#print ip + " - " + name + " - " + directory

		vhost_dir = '/var/lib/larpe'

		conf_dir = '%s/%s' % (vhost_dir, values['proxy_name'])

		if not os.path.exists(conf_dir):

			os.makedirs(conf_dir, mode = 0755)

		if not os.path.isdir(conf_dir):

			raise IOError()

		conf_file = open('%s/%s' % (conf_dir, 'apache2-vhost.conf'), 'w')

		try:

			conf_file.write("""NameVirtualHost %(proxy_ip)s:%(proxy_port)s

<VirtualHost %(proxy_ip)s:%(proxy_port)s>

	ServerName %(proxy_name)s

	# ServerAdmin admin@test.org

	# LoadFile		/usr/lib/libxml2.so.2

	SetOutputFilter	proxy-html

	<Location %(proxy_directory)s>

		ProxyPass			%(site_address)s

		ProxyPassReverse	%(site_address)s

		ProxyHTMLURLMap		/		%(proxy_directory)s

		ProxyHTMLURLMap		%(site_address)s		%(proxy_directory)s

	</Location>

</VirtualHost>

""" % values)

		finally:

			conf_file.close()

from quixote.directory import Directory

from template import generate_html

from apache_form import ApacheForm

class ApacheNew(Directory):

	"""

	Apache administration directory

	"""

	_q_exports = ['']

	def _q_index [html] (self):

		"""Error"""

		return

	def _q_lookup [html] (self, server_name):

		form = ApacheForm()

		generate_html('apache', form.handle())

from quixote.directory import Directory

from template import generate_html

from apache_form import ApacheForm

class ApacheVhost(Directory):

	"""

	Apache vhost management

	"""

	_q_exports = ['', 'edit']

	def __init__(self, server_name):

		self.server_name = server_name

	def _q_index [html] (self):

		"""ok"""

	def _q_lookup [html] (self, component):

		component + " " + self.server_name

	def edit [html] (self):

		'test'

@import url(../wcs-common.css);

html, body {

	margin: 0;

	background: white url(page-bg.png) repeat-y;

}

div#main-content {

	margin-left: 160px;

	margin-top: -10px;

	margin-right: 20px;

}

div#main-content h1 {

	color: #006699;

	font-size: 120%;

}

div#main-content h2 {

	color: #006699;

	font-size: 115%;

}

div#main-content h3 {

	color: #006699;

	font-size: 108%

}

div#header {

	margin: 0;

	background: white url(head-bg.png) repeat-x;

	height: 58px;

}

ul#menu {

	background: transparent url(head-logo-larpe.png) no-repeat;

	width: 177px;

	margin: 0;

	padding: 80px 0 0 5px;

}

a {

	color: #0066cc;

	text-decoration: none;

	border-bottom: 1px dotted #ff9900;

}

p.commands a {

	border: 0;

}

ul#menu a {

	font-weight: bold;

}

ul#menu li.active a {

	border-bottom: 1px solid #ff9900;

}

ul#menu li {

	font-size: 90%;

	margin-bottom: 1em;

	max-width: 130px;

}

div#footer {

	display: none;

}

ul.user-info {

	position: absolute;

	margin: 0;

	padding: 0;

	right: 25px;

	top: 13px;

	font-size: 70%;

	font-weight: bold;

}

ul.user-info li {

	display: inline;

	padding-left: 10px;

}

/** end of dc2 changes **/

ul.biglist {

	margin: 0;

	padding: 0;

}

ul.biglist li {

	list-style-type: none;

	margin: 4px 0;

	padding: 0 2px;

	border: 1px solid #888;

	background: #ffe;

	clear: both;

}

ul.biglist li p.details {

	display: block;

	margin: 0;

	color: #555;

	font-size: 80%;

}

ul.biglist li p.commands {

	float: right;

	margin-top: -17px;

}

ul.biglist li p.commands img {

	padding-right: 5px;

}

a img {

	border: 0;

}

td.time {

	text-align: right;

}

ul.biglist li.disabled, ul.biglist li.disabled p.details {

	color: #999;

	background: #ddd;

}

dl dt {

	margin : 0;

	padding : 0 0 0 0;

}

dl dd {

        margin : 0.3em 0 1.5em 10px;

}

img.theme-icon {

	float: right;

	margin: -16px 4px 0px 3px;

	border: 1px solid #999;

}

div#new-field table {

	margin: 0;

	padding: 0;

}

div#new-field div.widget {

	margin: 0;

	padding: 0;

}

div#new-field div.buttons {

	margin: 0;

	padding: 0;

}

div#new-field div.buttons input {

	margin: 0;

	padding: 0;

}

div#new-field {

	border: 1px solid #888;

	background: #ffe;

	margin: 2em 0 4px 0;

	padding: 0 2px;

}

div#new-field div.widget {

}

div#new-field h3 {

	margin: 0;

	font-size: 100%;

}

div#new-field br {

	display: none;

}

div#new-field p.commands {

	float: right;

	margin-top: -17px;

	margin-right: 3px;

}

div.WorkflowStatusWidget {

	border-left: 1px solid black;

}

p#breadcrumb {

	background: #e6e6e6;

	-moz-border-radius: 6px;

	padding: 3px 8px;

	font-size: 80%;

	border: 1px solid #bfbfbf;

}

/** steps **/

#steps {

	height: 32px;

	margin-bottom: 1em;

	background: #f0f0f0;

	color: #aaa;

}

#steps ol {

	list-style: none;

	padding: 0 20px;

}

#steps li {

	display: inline;

	padding-right: 1em;

	display: block;

	float: left;

	width: 30%;

	list-style: none;

}

#steps ol ul {

	display: none;

}

#steps span.marker {

	font-size: 26px;

	padding: 2px 9px;

	font-weight: bold;

	color: white;

	text-align: center;

	background: #ddd;

	border: 1px solid #ddd;

	-moz-border-radius: 0.7ex;

}

#steps li.current span.marker {

	background: #ffa500;

	border: 1px solid #ffc400;

}

#steps span.label {

	font-size: 90%;

}

#steps li.current span.label {

	color: black;

}

#steps ol ul {

	display: none;

}

/** logs **/

form#other-log-select {

	margin-top: 2em;

	padding-top: 1em;

	border-top: 1px solid #999;

}

form#other-log-select select {

	margin: 0 1em;

}

tr.level-error td {

	border: 1px solid #800;

	background: red;

}

tr.level-error td.message {

	font-weight: bold;

}

#!/usr/bin/env python

"""ezt.py -- easy templating

ezt templates are simply text files in whatever format you so desire

(such as XML, HTML, etc.) which contain directives sprinkled

throughout.  With these directives it is possible to generate the

dynamic content from the ezt templates.

These directives are enclosed in square brackets.  If you are a

C-programmer, you might be familar with the #ifdef directives of the C

preprocessor 'cpp'.  ezt provides a similar concept.  Additionally EZT

has a 'for' directive, which allows it to iterate (repeat) certain

subsections of the template according to sequence of data items

provided by the application.

The final rendering is performed by the method generate() of the Template

class.  Building template instances can either be done using external

EZT files (convention: use the suffix .ezt for such files):

    >>> template = Template("../templates/log.ezt")

or by calling the parse() method of a template instance directly with 

a EZT template string:

    >>> template = Template()

    >>> template.parse('''<html><head>

    ... <title>[title_string]</title></head>

    ... <body><h1>[title_string]</h1>

    ...    [for a_sequence] <p>[a_sequence]</p>

    ...    [end] <hr>

    ...    The [person] is [if-any state]in[else]out[end].

    ... </body>

    ... </html>

    ... ''')

The application should build a dictionary 'data' and pass it together

with the output fileobject to the templates generate method:

    >>> data = {'title_string' : "A Dummy Page",

    ...         'a_sequence' : ['list item 1', 'list item 2', 'another element'],

    ...         'person': "doctor",

    ...         'state' : None }

    >>> import sys

    >>> template.generate(sys.stdout, data)

    <html><head>

    <title>A Dummy Page</title></head>

    <body><h1>A Dummy Page</h1>

     <p>list item 1</p>

     <p>list item 2</p>

     <p>another element</p>

     <hr>

    The doctor is out.

    </body>

    </html>

Template syntax error reporting should be improved.  Currently it is 

very sparse (template line numbers would be nice):

    >>> Template().parse("[if-any where] foo [else] bar [end unexpected args]")

    Traceback (innermost last):

      File "<stdin>", line 1, in ?

      File "ezt.py", line 220, in parse

        self.program = self._parse(text)

      File "ezt.py", line 275, in _parse

        raise ArgCountSyntaxError(str(args[1:]))

    ArgCountSyntaxError: ['unexpected', 'args']

    >>> Template().parse("[if unmatched_end]foo[end]")

    Traceback (innermost last):

      File "<stdin>", line 1, in ?

      File "ezt.py", line 206, in parse

        self.program = self._parse(text)

      File "ezt.py", line 266, in _parse

        raise UnmatchedEndError()

    UnmatchedEndError

Directives

==========

 Several directives allow the use of dotted qualified names refering to objects

 or attributes of objects contained in the data dictionary given to the 

 .generate() method.

 Qualified names

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

   Qualified names have two basic forms: a variable reference, or a string

   constant. References are a name from the data dictionary with optional

   dotted attributes (where each intermediary is an object with attributes,

   of course).

   Examples:

     [varname]

     [ob.attr]

     ["string"]

 Simple directives

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

   [QUAL_NAME]

   This directive is simply replaced by the value of the qualified name.

   If the value is a number it's converted to a string before being 

   outputted. If it is None, nothing is outputted. If it is a python file

   object (i.e. any object with a "read" method), it's contents are

   outputted. If it is a callback function (any callable python object

   is assumed to be a callback function), it is invoked and passed an EZT

   printer function as an argument.

   [QUAL_NAME QUAL_NAME ...]

   If the first value is a callback function, it is invoked with the

   output file pointer as a first argument, and the rest of the values as

   additional arguments.

   Otherwise, the first value defines a substitution format, specifying

   constant text and indices of the additional arguments. The arguments

   are substituted and the result is inserted into the output stream.

   Example:

     ["abc %0 def %1 ghi %0" foo bar.baz]

   Note that the first value can be any type of qualified name -- a string

   constant or a variable reference. Use %% to substitute a percent sign.

   Argument indices are 0-based.

   [include "filename"]  or [include QUAL_NAME]

   This directive is replaced by content of the named include file. Note

   that a string constant is more efficient -- the target file is compiled

   inline. In the variable form, the target file is compiled and executed

   at runtime.

 Block directives

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

   [for QUAL_NAME] ... [end]

   The text within the [for ...] directive and the corresponding [end]

   is repeated for each element in the sequence referred to by the

   qualified name in the for directive.  Within the for block this

   identifiers now refers to the actual item indexed by this loop

   iteration.

   [if-any QUAL_NAME [QUAL_NAME2 ...]] ... [else] ... [end]

   Test if any QUAL_NAME value is not None or an empty string or list.

   The [else] clause is optional.  CAUTION: Numeric values are

   converted to string, so if QUAL_NAME refers to a numeric value 0,

   the then-clause is substituted!

   [if-index INDEX_FROM_FOR odd] ... [else] ... [end]

   [if-index INDEX_FROM_FOR even] ... [else] ... [end]

   [if-index INDEX_FROM_FOR first] ... [else] ... [end]

   [if-index INDEX_FROM_FOR last] ... [else] ... [end]

   [if-index INDEX_FROM_FOR NUMBER] ... [else] ... [end]

   These five directives work similar to [if-any], but are only useful

   within a [for ...]-block (see above).  The odd/even directives are

   for example useful to choose different background colors for

   adjacent rows in a table.  Similar the first/last directives might

   be used to remove certain parts (for example "Diff to previous"

   doesn't make sense, if there is no previous).

   [is QUAL_NAME STRING] ... [else] ... [end]

   [is QUAL_NAME QUAL_NAME] ... [else] ... [end]

   The [is ...] directive is similar to the other conditional

   directives above.  But it allows to compare two value references or

   a value reference with some constant string.

   [define VARIABLE] ... [end]

   The [define ...] directive allows you to create and modify template

   variables from within the template itself.  Essentially, any data

   between inside the [define ...] and its matching [end] will be

   expanded using the other template parsing and output generation

   rules, and then stored as a string value assigned to the variable

   VARIABLE.  The new (or changed) variable is then available for use

   with other mechanisms such as [is ...] or [if-any ...], as long as

   they appear later in the template.

   [format STRING] ... [end]

   The format directive controls how the values substituted into

   templates are escaped before they are put into the output stream. It

   has no effect on the literal text of the templates, only the output

   from [QUAL_NAME ...] directives. STRING can be one of "raw" "html" 

   or "xml". The "raw" mode leaves the output unaltered. The "html" and

   "xml" modes escape special characters using entity escapes (like

   " and >)

"""

#

# Copyright (C) 2001-2005 Greg Stein. All Rights Reserved.

#

# Redistribution and use in source and binary forms, with or without 

# modification, are permitted provided that the following conditions are 

# met:

#

# * Redistributions of source code must retain the above copyright 

#   notice, this list of conditions and the following disclaimer. 

#

# * Redistributions in binary form must reproduce the above copyright 

#   notice, this list of conditions and the following disclaimer in the 

#   documentation and/or other materials provided with the distribution. 

#

# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS 

# IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 

# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 

# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE 

# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 

# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 

# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 

# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 

# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 

# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 

# POSSIBILITY OF SUCH DAMAGE.

#

#

# This software is maintained by Greg and is available at:

#    http://svn.webdav.org/repos/projects/ezt/trunk/

#

import string

import re

from types import StringType, IntType, FloatType, LongType

import os

import cgi

try:

  import cStringIO

except ImportError:

  import StringIO

  cStringIO = StringIO

#

# Formatting types

#

FORMAT_RAW = 'raw'

FORMAT_HTML = 'html'

FORMAT_XML = 'xml'

#

# This regular expression matches three alternatives:

#   expr: DIRECTIVE | BRACKET | COMMENT

#   DIRECTIVE: '[' ITEM (whitespace ITEM)* ']

#   ITEM: STRING | NAME

#   STRING: '"' (not-slash-or-dquote | '\' anychar)* '"'

#   NAME: (alphanum | '_' | '-' | '.')+

#   BRACKET: '[[]'

#   COMMENT: '[#' not-rbracket* ']'

#

# When used with the split() method, the return value will be composed of

# non-matching text and the two paren groups (DIRECTIVE and BRACKET). Since

# the COMMENT matches are not placed into a group, they are considered a

# "splitting" value and simply dropped.

#

_item = r'(?:"(?:[^\\"]|\\.)*"|[-\w.]+)'

_re_parse = re.compile(r'\[(%s(?: +%s)*)\]|(\[\[\])|\[#[^\]]*\]' % (_item, _item))

_re_args = re.compile(r'"(?:[^\\"]|\\.)*"|[-\w.]+')

# block commands and their argument counts

_block_cmd_specs = { 'if-index':2, 'for':1, 'is':2, 'define':1, 'format':1 }

_block_cmds = _block_cmd_specs.keys()

# two regular expresssions for compressing whitespace. the first is used to

# compress any whitespace including a newline into a single newline. the

# second regex is used to compress runs of whitespace into a single space.

_re_newline = re.compile('[ \t\r\f\v]*\n\\s*')

_re_whitespace = re.compile(r'\s\s+')

# this regex is used to substitute arguments into a value. we split the value,

# replace the relevant pieces, and then put it all back together. splitting

# will produce a list of: TEXT ( splitter TEXT )*. splitter will be '%' or

# an integer.

_re_subst = re.compile('%(%|[0-9]+)')

class Template:

  _printers = {

    FORMAT_RAW  : '_cmd_print',

    FORMAT_HTML : '_cmd_print_html',

    FORMAT_XML  : '_cmd_print_xml',

    }

  def __init__(self, fname=None, compress_whitespace=1,

               base_format=FORMAT_RAW):

    self.compress_whitespace = compress_whitespace

    if fname:

      self.parse_file(fname, base_format)

  def parse_file(self, fname, base_format=FORMAT_RAW):

    "fname -> a string object with pathname of file containg an EZT template."

    self.parse(_FileReader(fname), base_format)

  def parse(self, text_or_reader, base_format=FORMAT_RAW):

    """Parse the template specified by text_or_reader.

    The argument should be a string containing the template, or it should

    specify a subclass of ezt.Reader which can read templates. The base

    format for printing values is given by base_format.

    """

    if not isinstance(text_or_reader, Reader):

      # assume the argument is a plain text string

      text_or_reader = _TextReader(text_or_reader)

    printer = getattr(self, self._printers[base_format])

    self.program = self._parse(text_or_reader, base_printer=printer)

  def generate(self, fp, data):

    if hasattr(data, '__getitem__') or callable(getattr(data, 'keys', None)):

      # a dictionary-like object was passed. convert it to an

      # attribute-based object.

      class _data_ob:

        def __init__(self, d):

          vars(self).update(d)

      data = _data_ob(data)

    ctx = _context()

    ctx.data = data

    ctx.for_index = { }

    ctx.defines = { }

    self._execute(self.program, fp, ctx)

  def _parse(self, reader, for_names=None, file_args=(), base_printer=None):

    """text -> string object containing the template.

    This is a private helper function doing the real work for method parse.

    It returns the parsed template as a 'program'.  This program is a sequence

    made out of strings or (function, argument) 2-tuples.

    Note: comment directives [# ...] are automatically dropped by _re_parse.

    """

    # parse the template program into: (TEXT DIRECTIVE BRACKET)* TEXT

    parts = _re_parse.split(reader.text)

    program = [ ]

    stack = [ ]

    if not for_names:

      for_names = [ ]

    if base_printer:

      printers = [ base_printer ]

    else:

      printers = [ self._cmd_print ]

    for i in range(len(parts)):

      piece = parts[i]

      which = i % 3  # discriminate between: TEXT DIRECTIVE BRACKET

      if which == 0:

        # TEXT. append if non-empty.

        if piece:

          if self.compress_whitespace:

            piece = _re_whitespace.sub(' ', _re_newline.sub('\n', piece))

          program.append(piece)

      elif which == 2:

        # BRACKET directive. append '[' if present.

        if piece:

          program.append('[')

      elif piece:

        # DIRECTIVE is present.

        args = _re_args.findall(piece)

        cmd = args[0]

        if cmd == 'else':

          if len(args) > 1:

            raise ArgCountSyntaxError(str(args[1:]))

          ### check: don't allow for 'for' cmd

          idx = stack[-1][1]

          true_section = program[idx:]

          del program[idx:]

          stack[-1][3] = true_section

        elif cmd == 'end':

          if len(args) > 1:

            raise ArgCountSyntaxError(str(args[1:]))

          # note: true-section may be None

          try:

            cmd, idx, args, true_section = stack.pop()

          except IndexError:

            raise UnmatchedEndError()

          else_section = program[idx:]

          if cmd == 'format':

            printers.pop()

          else:

            func = getattr(self, '_cmd_' + re.sub('-', '_', cmd))

            program[idx:] = [ (func, (args, true_section, else_section)) ]

            if cmd == 'for':

              for_names.pop()

        elif cmd in _block_cmds:

          if len(args) > _block_cmd_specs[cmd] + 1:

            raise ArgCountSyntaxError(str(args[1:]))

          ### this assumes arg1 is always a ref unless cmd is 'define'

          if cmd != 'define':

            args[1] = _prepare_ref(args[1], for_names, file_args)

          # handle arg2 for the 'is' command

          if cmd == 'is':

            args[2] = _prepare_ref(args[2], for_names, file_args)

          elif cmd == 'for':

            for_names.append(args[1][0])  # append the refname

          elif cmd == 'format':

            if args[1][0]:

              raise BadFormatConstantError(str(args[1:]))

            funcname = self._printers.get(args[1][1])

            if not funcname:

              raise UnknownFormatConstantError(str(args[1:]))

            printers.append(getattr(self, funcname))

          # remember the cmd, current pos, args, and a section placeholder

          stack.append([cmd, len(program), args[1:], None])

        elif cmd == 'include':

          if args[1][0] == '"':

            include_filename = args[1][1:-1]

            f_args = [ ]

            for arg in args[2:]:

              f_args.append(_prepare_ref(arg, for_names, file_args))

            program.extend(self._parse(reader.read_other(include_filename),

                                       for_names, f_args, printers[-1]))

          else:

            if len(args) != 2:

              raise ArgCountSyntaxError(str(args))

            program.append((self._cmd_include,

                            (_prepare_ref(args[1], for_names, file_args),

                             reader)))

        elif cmd == 'if-any':

          f_args = [ ]

          for arg in args[1:]:

            f_args.append(_prepare_ref(arg, for_names, file_args))

          stack.append(['if-any', len(program), f_args, None])

        else:

          # implied PRINT command

          f_args = [ ]

          for arg in args:

            f_args.append(_prepare_ref(arg, for_names, file_args))

          program.append((printers[-1], f_args))

    if stack:

      ### would be nice to say which blocks...

      raise UnclosedBlocksError()

    return program

  def _execute(self, program, fp, ctx):

    """This private helper function takes a 'program' sequence as created

    by the method '_parse' and executes it step by step.  strings are written

    to the file object 'fp' and functions are called.

    """

    for step in program:

      if isinstance(step, StringType):

        fp.write(step)

      else:

        step[0](step[1], fp, ctx)

  def _cmd_print(self, valref, fp, ctx):

    _write_value(valref, fp, ctx)

  def _cmd_print_html(self, valref, fp, ctx):

    _write_value(valref, fp, ctx, cgi.escape)

  def _cmd_print_xml(self, valref, fp, ctx):

    ### use the same quoting as HTML for now

    self._cmd_print_html(valref, fp, ctx)

  def _cmd_include(self, (valref, reader), fp, ctx):

    fname = _get_value(valref, ctx)

    ### note: we don't have the set of for_names to pass into this parse.

    ### I don't think there is anything to do but document it. we also

    ### don't have a current format (since that is a compile-time concept).

    self._execute(self._parse(reader.read_other(fname)), fp, ctx)

  def _cmd_if_any(self, args, fp, ctx):

    "If any value is a non-empty string or non-empty list, then T else F."

    (valrefs, t_section, f_section) = args

    value = 0

    for valref in valrefs:

      if _get_value(valref, ctx):

        value = 1

        break

    self._do_if(value, t_section, f_section, fp, ctx)

  def _cmd_if_index(self, args, fp, ctx):

    ((valref, value), t_section, f_section) = args

    list, idx = ctx.for_index[valref[0]]

    if value == 'even':

      value = idx % 2 == 0

    elif value == 'odd':

      value = idx % 2 == 1

    elif value == 'first':

      value = idx == 0

    elif value == 'last':

      value = idx == len(list)-1

    else:

      value = idx == int(value)

    self._do_if(value, t_section, f_section, fp, ctx)

  def _cmd_is(self, args, fp, ctx):

    ((left_ref, right_ref), t_section, f_section) = args

    value = _get_value(right_ref, ctx)

    value = string.lower(_get_value(left_ref, ctx)) == string.lower(value)

    self._do_if(value, t_section, f_section, fp, ctx)

  def _do_if(self, value, t_section, f_section, fp, ctx):

    if t_section is None:

      t_section = f_section

      f_section = None

    if value:

      section = t_section

    else:

      section = f_section

    if section is not None:

      self._execute(section, fp, ctx)

  def _cmd_for(self, args, fp, ctx):

    ((valref,), unused, section) = args

    list = _get_value(valref, ctx)

    if isinstance(list, StringType):

      raise NeedSequenceError()

    refname = valref[0]

    ctx.for_index[refname] = idx = [ list, 0 ]

    for item in list:

      self._execute(section, fp, ctx)

      idx[1] = idx[1] + 1

    del ctx.for_index[refname]

  def _cmd_define(self, args, fp, ctx):

    ((name,), unused, section) = args

    valfp = cStringIO.StringIO()

    if section is not None:

      self._execute(section, valfp, ctx)

    ctx.defines[name] = valfp.getvalue()

def boolean(value):

  "Return a value suitable for [if-any bool_var] usage in a template."

  if value:

    return 'yes'

  return None

def _prepare_ref(refname, for_names, file_args):

  """refname -> a string containing a dotted identifier. example:"foo.bar.bang"

  for_names -> a list of active for sequences.

  Returns a `value reference', a 3-tuple made out of (refname, start, rest), 

  for fast access later.

  """

  # is the reference a string constant?

  if refname[0] == '"':

    return None, refname[1:-1], None

  parts = string.split(refname, '.')

  start = parts[0]

  rest = parts[1:]

  # if this is an include-argument, then just return the prepared ref

  if start[:3] == 'arg':

    try:

      idx = int(start[3:])

    except ValueError:

      pass

    else:

      if idx < len(file_args):

        orig_refname, start, more_rest = file_args[idx]

        if more_rest is None:

          # the include-argument was a string constant

          return None, start, None

        # prepend the argument's "rest" for our further processing

        rest[:0] = more_rest

        # rewrite the refname to ensure that any potential 'for' processing

        # has the correct name

        ### this can make it hard for debugging include files since we lose

        ### the 'argNNN' names

        if not rest:

          return start, start, [ ]

        refname = start + '.' + string.join(rest, '.')

  if for_names:

    # From last to first part, check if this reference is part of a for loop

    for i in range(len(parts), 0, -1):

      name = string.join(parts[:i], '.')

      if name in for_names:

        return refname, name, parts[i:]

  return refname, start, rest

def _get_value((refname, start, rest), ctx):

  """(refname, start, rest) -> a prepared `value reference' (see above).

  ctx -> an execution context instance.

  Does a name space lookup within the template name space.  Active 

  for blocks take precedence over data dictionary members with the 

  same name.

  """

  if rest is None:

    # it was a string constant

    return start

  # get the starting object

  if ctx.for_index.has_key(start):

    list, idx = ctx.for_index[start]

    ob = list[idx]

  elif ctx.defines.has_key(start):

    ob = ctx.defines[start]

  elif hasattr(ctx.data, start):

    ob = getattr(ctx.data, start)

  else:

    raise UnknownReference(refname)

  # walk the rest of the dotted reference

  for attr in rest:

    try:

      ob = getattr(ob, attr)

    except AttributeError:

      raise UnknownReference(refname)

  # make sure we return a string instead of some various Python types

  if isinstance(ob, IntType) \

         or isinstance(ob, LongType) \

         or isinstance(ob, FloatType):

    return str(ob)

  if ob is None:

    return ''

  # string or a sequence

  return ob

def _write_value(valrefs, fp, ctx, format=lambda s: s):

  value = _get_value(valrefs[0], ctx)

  args = map(lambda valref, ctx=ctx: _get_value(valref, ctx), valrefs[1:])

  # if the value has a 'read' attribute, then it is a stream: copy it

  if hasattr(value, 'read'):

    while 1:

      chunk = value.read(16384)

      if not chunk:

        break

      fp.write(format(chunk))

  # value is a callback function: call with file pointer and extra args

  elif callable(value):

    apply(value, [fp] + args)

  # value is a substitution pattern

  elif args:

    parts = _re_subst.split(value)

    for i in range(len(parts)):

      piece = parts[i]

      if i%2 == 1 and piece != '%':

        idx = int(piece)

        if idx < len(args):

          piece = args[idx]

        else:

          piece = '<undef>'

      if format:

        fp.write(format(piece))

  # plain old value, write to output

  else:

    fp.write(format(value))

class _context:

  """A container for the execution context"""

class Reader:

  "Abstract class which allows EZT to detect Reader objects."

class _FileReader(Reader):

  """Reads templates from the filesystem."""

  def __init__(self, fname):

    self.text = open(fname, 'rb').read()

    self._dir = os.path.dirname(fname)

  def read_other(self, relative):

    return _FileReader(os.path.join(self._dir, relative))

class _TextReader(Reader):

  """'Reads' a template from provided text."""

  def __init__(self, text):

    self.text = text

  def read_other(self, relative):

    raise BaseUnavailableError()

class EZTException(Exception):

  """Parent class of all EZT exceptions."""

class ArgCountSyntaxError(EZTException):

  """A bracket directive got the wrong number of arguments."""

class UnknownReference(EZTException):

  """The template references an object not contained in the data dictionary."""

class NeedSequenceError(EZTException):

  """The object dereferenced by the template is no sequence (tuple or list)."""

class UnclosedBlocksError(EZTException):

  """This error may be simply a missing [end]."""

class UnmatchedEndError(EZTException):

  """This error may be caused by a misspelled if directive."""

class BaseUnavailableError(EZTException):

  """Base location is unavailable, which disables includes."""

class BadFormatConstantError(EZTException):

  """Format specifiers must be string constants."""

class UnknownFormatConstantError(EZTException):

  """The format specifier is an unknown value."""

# --- standard test environment ---

def test_parse():

  assert _re_parse.split('[a]') == ['', '[a]', None, '']

  assert _re_parse.split('[a] [b]') == \

         ['', '[a]', None, ' ', '[b]', None, '']

  assert _re_parse.split('[a c] [b]') == \

         ['', '[a c]', None, ' ', '[b]', None, '']

  assert _re_parse.split('x [a] y [b] z') == \

         ['x ', '[a]', None, ' y ', '[b]', None, ' z']

  assert _re_parse.split('[a "b" c "d"]') == \

         ['', '[a "b" c "d"]', None, '']

  assert _re_parse.split(r'["a \"b[foo]" c.d f]') == \

         ['', '["a \\"b[foo]" c.d f]', None, '']

def _test(argv):

  import doctest, ezt           

  verbose = "-v" in argv

  return doctest.testmod(ezt, verbose=verbose)

if __name__ == "__main__":

  # invoke unit test for this module:

  import sys

  sys.exit(_test(sys.argv)[0])

import os

import quixote

from quixote import get_response

#from wcs import storage

#from wcs import misc

#from wcs.users import User

items = [

    ('apache', 'Apache')]

#    ('forms', N_('Forms')),

    #('consultations', N_('Consultations')),

#    ('workflows', N_('Workflows')),

#    ('users', N_('Users')),

#    ('roles', N_('Roles')),

#    ('categories', N_('Categories')),

#    ('logger', N_('Logs')),

#    ('settings', N_('Settings')),

#    ('/', N_('WCS Form Server'))]

def generate_header_menu [html] (selected = None):

    s = ["""<ul id="menu">\n"""]

    base_url = quixote.get_request().environ['SCRIPT_NAME'] + '/admin'

#    features = misc.cfg.get('misc', {}).get('features', 'both')

#    show_logger = misc.cfg.get('debug', {}).get('logger', False)

    for k, v in items:

        if k == '/':

            continue # skip root

#        if k == 'logger' and not show_logger:

#            continue

#        if features == 'forms' and k == 'consultations':

#            continue

#        if features == 'consultations' and k == 'forms':

#            continue

        if k == selected:

            s.append('<li class="active">')

        else:

            s.append('<li>')

        s.append('<a href="%s/%s/">%s</a></li>\n' % (base_url, k, v))

    s.append('</ul>\n')

    return ''.join(s)

#def generate_user_info [html] ():

#    session = quixote.get_session()

#    if not session or not session.user:

#        return ''

#    try:

#        user = User.get(session.user)

#        username = user.name

#    except KeyError:

#        username = _('Unknown')

#    logout_url = quixote.get_request().environ['SCRIPT_NAME'] + '/logout'

#    """<ul class="user-info">

#  <li class="ui-name">%s</li>

#  <li class="ui-logout"><a href="%s">%s</a></li>

#</ul>""" % (username, logout_url, _('logout'))

def html_top [html] (section, title = None, scripts = None):

    header_menu = generate_header_menu(section)

#    user_info = generate_user_info()

    subtitle = ''

    for s in items:

        if s[0] == section:

            subtitle = _(s[1])

    if not title:

        title = ''

    else:

        title = ' - ' + title

    if not scripts:

        scripts = ''

    else:

        scripts = '\n'.join(['<script src="%s" type="text/javascript"></script>' % x for x in scripts])

    sitetitle = 'Larpe Administration'

    if title:

        sitetitle += ' - '

    admin_ezt = True

    """

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

<head>

<title>Administration de Larpe</title>

<link rel="stylesheet" type="text/css" href="/css/larpe-admin.css"/>

<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />

</head>

<body>

<div id="header">%s

</div>

<div id="main-content">

<p id="breadcrumb"><a href="/">Administration</a></p>

<h1>Relai inverse Liberty Alliance</h1>

</div>

<div id="footer">

<p id="lasso">Powered by Lasso</p>

</div>

</body>

</html>

""" % header_menu

#<ul id="menu">

#<li><a href="/admin/apache/">Apache</a></li>

#</ul>

#</div>

#<div id="main-content">

	#    get_response().

#    get_response().filter.update(locals())

def error_page [html] (section, error):

    html_top(section, title = _('Error'))

    '<div id="error-page">'

    '<h2>%s</h2>' % _('Error')

    '<p>%s</p>' % error

    '</div>'

#def command_icon [html] (url, type, label = None, icon = None):

#    icons = {

#        'edit': 'stock_edit_16.png',

#        'add': 'stock_add_16.png',

#        'remove': 'stock_remove_16.png',

#        'duplicate': 'stock_copy_16.png',

#        'view': 'view_16.png',

#    }

#    labels = {

#        'add': N_('Add'),

#        'edit': N_('Edit'),

#        'remove': N_('Remove'),

#        'duplicate': N_('Duplicate'),

#        'view': N_('View'),

#        }

#    if not label:

#        label = _(labels[str(type)])

#    if not icon:

#        icon = icons[str(type)]

#    if url:

#        '''<span class="%(type)s">

#  <a href="%(url)s"><img src="/images/%(icon)s" alt="%(label)s" title="%(label)s" /></a>

#</span>''' % locals()

#    else:

#        # no url -> image button

#        '''<span class="%(type)s">

#  <input type="image" src="/images/%(icon)s" alt="%(label)s" title="%(label)s" />

#</span>''' % locals()

from quixote.directory import Directory

#from menu import html_top

from template import generate_html

from apache import Apache

class RootDirectory(Directory):

	_q_exports = ['', 'apache']

	apache = Apache()

	def _q_index [html] (self):

		text = """<p>Choisissez dans le menu ce que vous souhaitez administrer</p>"""

		generate_html(None, text)

		#html_top('/')

from cStringIO import StringIO

from quixote.html import htmltext

import ezt

#<?xml version="1.0" encoding="utf-8"?>

#    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />

ADMIN_TEMPLATE_EZT = """<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

  <head>

    <title>Administration de Larpe - [page_title]</title>

    <link rel="stylesheet" type="text/css" href="/css/larpe-admin.css"/>

  </head>

  <body>

  <div id="header">[main_menu]</div>

  <div id="main-content">

    <p id="breadcrumb">[breadcrumb]</p>

    <h1>[subtitle]</h1>

    [body]

  </div>

  <div id="footer">

   <p id="lasso">Powered by Lasso</p>

  </div>

 </body>

</html>"""

admin_template = ezt.Template()

admin_template.parse(ADMIN_TEMPLATE_EZT)

menu_items = [

    ('apache', 'Apache')]

def generate_main_menu(selected = None):

    s = '<ul id="menu">\n'

    for k, v in menu_items:

        if k == selected:

            s += '<li class="active">'

        else:

            s += '<li>'

        s += '<a href="/%s/">%s</a></li>\n' % (k, v)

    s + '</ul>\n'

    return s

def generate_breadcrumb(section = None):

	s = '<a href="/">Administration</a>'

	if section is not None:

	    for k, v in menu_items:

	    	if k == section:

				s += ' > <a href="/%s">%s</a>' % (k, v)

				break

	return s

def generate_html(section, body):

	if section is not None:

		section = str(section)

	body = str(body)

	main_menu = generate_main_menu(section)

	breadcrumb = generate_breadcrumb(section)

	page_title = ''

	if section is not None:

	    for k, v in menu_items:

	    	if k == section:

				page_title = v				

				break

	subtitle = page_title

	fd = StringIO()

	admin_template.generate(fd, locals())

	return htmltext(fd.getvalue())

<VirtualHost 127.0.0.6:80>

  ServerName entrouvert.test.org

  ServerAdmin dlaniel@entrouvert.com

  SetOutputFilter	proxy-html

  <Location />

    ProxyPass		http://www.entrouvert.com/

    ProxyPassReverse	http://www.entrouvert.com/

#    ProxyPassReverse	/

#    ProxyHTMLURLMap	/	/eo/

  </Location>

</VirtualHost>

NameVirtualHost 127.0.0.6:80

<VirtualHost 127.0.0.6:80>

  ServerName test.org

#  ServerAdmin dlaniel@entrouvert.com

#  LoadFile		/usr/lib/libxml2.so.2

  SetOutputFilter	proxy-html

#  ProxyPass /eo/ http://www.entrouvert.com/

#  ProxyPassReverse /eo/ http://www.entrouvert.com/

  <Location /eo/>

    ProxyPass		http://www.entrouvert.com/

    ProxyPassReverse	http://www.entrouvert.com/

#    ProxyPassReverse	/

    ProxyHTMLURLMap	/	/eo/

  </Location>

  <Location /linuxfr/>

    ProxyPass		http://linuxfr.org/

    ProxyPassReverse	http://linuxfr.org/

    ProxyHTMLURLMap	/	/linuxfr/

    ProxyHTMLURLMap	http://linuxfr.org/	/linuxfr/

  </Location>

  <Location /libe/>

    ProxyPass		http://www.liberation.fr/

#    ProxyPassReverse	/

    ProxyHTMLURLMap	/	  /libe/

    ProxyHTMLURLMap	http://www.liberation.fr/	/libe/

  </Location>

#  <Location *>

#    ProxyPass		!

#  </Location>

</VirtualHost>