def write_with_template(self, fname, tname, data):
fout = StringIO()
template = ezt.Template(compress_whitespace = 0)
template.parse_file(os.path.join('build', 'generator', tname))
template.generate(fout, data)
self.write_file_if_changed(fname, fout.getvalue())
def gen_tags(self, tags):
for key in tags.keys():
s = StringIO.StringIO()
t = ezt.Template(compress_whitespace=0)
t.parse(tags[key])
t.generate(s, self.data)
tags[key] = s.getvalue()
return
def _runTemplate(self, template, data, fmt=ezt.FORMAT_RAW):
# parse() takes a str, not bytes. assume utf-8.
if PY3 and isinstance(template, bytes):
template = template.decode('utf-8')
t = ezt.Template()
t.parse(template, base_format=fmt)
o = StringIO()
t.generate(o, data)
return o.getvalue()
def write_pkg_config_dot_in_files(self, install_sources):
"""Write pkg-config .pc.in files for Subversion libraries."""
for target_ob in install_sources:
if not (isinstance(target_ob, gen_base.TargetLib) and
target_ob.path.startswith('subversion/libsvn_')):
continue
lib_name = target_ob.name
lib_path = self.sections[lib_name].options.get('path')
lib_deps = self.sections[lib_name].options.get('libs')
lib_desc = self.sections[lib_name].options.get('description')
output_path = build_path_join(lib_path, lib_name + '.pc.in')
template = ezt.Template(os.path.join('build', 'generator', 'templates',
'pkg-config.in.ezt'),
compress_whitespace=False)
class _eztdata(object):
def __init__(self, **kw):
vars(self).update(kw)
data = _eztdata(
lib_name=lib_name,
lib_desc=lib_desc,
lib_deps=[],
lib_required=[],
lib_required_private=[],
version=self.version,
)
# libsvn_foo -> -lsvn_foo-1
data.lib_deps.append('-l%s-%s' % (lib_name.replace('lib', '', 1), data.version))
for lib_dep in lib_deps.split():
if lib_dep == 'apriconv':
# apriconv is part of apr-util, skip it
continue
external_lib = self.sections[lib_dep].options.get('external-lib')
if external_lib:
### Some of Subversion's internal libraries can appear as external
### libs to handle conditional compilation. Skip these for now.
if external_lib in ['$(SVN_RA_LIB_LINK)', '$(SVN_FS_LIB_LINK)']:
continue
# If the external library is known to support pkg-config,
# add it to the Required: or Required.private: section.
# Otherwise, add the external library to linker flags.
pkg_config = self.sections[lib_dep].options.get('pkg-config')
if pkg_config:
private = self.sections[lib_dep].options.get('pkg-config-private')
if private:
data.lib_required_private.append(pkg_config)
else:
data.lib_required.append(pkg_config)
else:
# $(EXTERNAL_LIB) -> @EXTERNAL_LIB@
data.lib_deps.append('@%s@' % external_lib[2:-1])
else:
data.lib_required_private.append(lib_dep)
template.generate(open(output_path, 'w'), data)
def generate(ifile, ofile, dict):
ifd = open(ifile, "r")
itext = ifd.read()
ifd.close()
ofd = open(ofile, "w")
t = ezt.Template(compress_whitespace = 0)
t.parse(itext)
t.generate(ofd, dict)
ofd.close()
def write_downloads(args):
'Output the download section of the website.'
sha1info = get_sha1info(args, replace=True)
data = { 'version' : str(args.version),
'fileinfo' : sha1info,
}
template = ezt.Template(compress_whitespace = False)
template.parse(get_tmplfile('download.ezt').read())
template.generate(sys.stdout, data)
def send_email(availid, template_dir, remote24, base_url):
logger.info('emailing availid=%s remote24=%s', availid, remote24)
infos = selfserve.ldap.validate_existence(availid, True)
keys = selfserve.keys.fetch_key(availid)
if selfserve.ldap.unprivileged_p(availid):
hextoken, expiry = selfserve.tokens.make_token(PW_RESET_MAGIC,
availid,
cookie=remote24)
else:
# root@ cannot reset their passwords. (Use ../maint/changepw.py instead.)
# Proceed normally, but without actually creating a token.
hextoken, expiry = (
selfserve.util.get_hexed_random_bytes(TOKEN_LENGTH),
int(time.time()) - 86400)
logger.warning(
"fabricating token=%s expiry=%d for privileged availid=%s",
hextoken, expiry, availid)
msgid = _make_msgid()
to = '*****@*****.**' % availid
tdata = {
'availid': availid,
'remote24': remote24,
'base_url': base_url,
'to': to,
'fullname': infos['fullname'],
'fromAddress': FROM_ADDRESS,
'SERVER_ADMIN': FROM_ADDRESS,
'token': hextoken,
'deadline': time.strftime(TIME_FMT, time.gmtime(expiry)),
'message_id': msgid,
}
template = ezt.Template(os.path.join(template_dir, 'resetpassword.email'),
compress_whitespace=False)
buffer = StringIO.StringIO()
template.generate(buffer, tdata)
rfc822text = buffer.getvalue()
rfc822text, crypted = _maybe_encrypt_rfc822(rfc822text,
infos['fingerprints'], keys)
# TODO: Update fail2ban if you change this message!
logger.warning(
"emailing password reset token to availid=%s message-id=<%s> remote24=%s encrypted=%s",
availid, msgid, remote24, str(crypted))
smtp = smtplib.SMTP(SMTP_HOST)
if SMTP_USER:
smtp.login(SMTP_USER, SMTP_PASSWORD)
smtp.sendmail(FROM_ADDRESS, to, rfc822text)
smtp.quit()
return msgid
def write_news(args):
'Write text for the Subversion website.'
data = {
'date': datetime.date.today().strftime('%Y%m%d'),
'date_pres': datetime.date.today().strftime('%Y-%m-%d'),
'version': str(args.version),
'version_base': args.version.base,
}
if args.version.is_prerelease():
template_filename = 'rc-news.ezt'
else:
template_filename = 'stable-news.ezt'
template = ezt.Template()
template.parse(get_tmplfile(template_filename).read())
template.generate(sys.stdout, data)
def gen(self, fname, temp_txt, data, tags):
f, lines = self.check_overwrite(fname)
if not f: # overwrite: No
return
if not lines: # overwrite: Yes
s = StringIO.StringIO()
t = ezt.Template(compress_whitespace=0)
t.parse(temp_txt)
t.generate(s, data)
taged_txt = s.getvalue().splitlines()
else: # overwrite: Merge mode
taged_txt = lines
# replace tags
gen_txt = self.replace_tags(taged_txt, tags)
f.write(gen_txt)
f.close()
print " File \"" + fname + "\"" " was generated."
return
def write_announcement(args):
'Write the release announcement.'
sha1info = get_sha1info(args)
data = {
'version': args.version,
'sha1info': sha1info,
'siginfo': open('getsigs-output', 'r').read(),
'major-minor': args.version.base[:3],
'major-minor-patch': args.version.base,
}
if args.version.is_prerelease():
template_filename = 'rc-release-ann.ezt'
else:
template_filename = 'stable-release-ann.ezt'
template = ezt.Template(compress_whitespace=False)
template.parse(get_tmplfile(template_filename).read())
template.generate(sys.stdout, data)
def write_announcement(args):
'Write the release announcement.'
sha1info = get_sha1info(args)
siginfo = "\n".join(get_siginfo(args, True)) + "\n"
data = {
'version': str(args.version),
'sha1info': sha1info,
'siginfo': siginfo,
'major-minor': '%d.%d' % (args.version.major, args.version.minor),
'major-minor-patch': args.version.base,
}
if args.version.is_prerelease():
template_filename = 'rc-release-ann.ezt'
else:
template_filename = 'stable-release-ann.ezt'
template = ezt.Template(compress_whitespace=False)
template.parse(get_tmplfile(template_filename).read())
template.generate(sys.stdout, data)
def post_candidates(args):
'Post the generated tarballs to web-accessible directory.'
if args.target:
target = args.target
else:
target = os.path.join(os.getenv('HOME'), 'public_html', 'svn',
args.version)
if args.code_name:
dirname = args.code_name
else:
dirname = 'deploy'
if not os.path.exists(target):
os.makedirs(target)
data = {
'version': args.version,
'revnum': args.revnum,
'dirname': dirname,
}
# Choose the right template text
if args.version.is_prerelease():
if args.version.pre == 'nightly':
template_filename = 'nightly-candidates.ezt'
else:
template_filename = 'rc-candidates.ezt'
else:
template_filename = 'stable-candidates.ezt'
template = ezt.Template()
template.parse(get_tmplfile(template_filename).read())
template.generate(open(os.path.join(target, 'index.html'), 'w'), data)
logging.info('Moving tarballs to %s' % os.path.join(target, dirname))
if os.path.exists(os.path.join(target, dirname)):
shutil.rmtree(os.path.join(target, dirname))
shutil.copytree(get_deploydir(args.base_dir),
os.path.join(target, dirname))
def gen_from_template(template_file: str, data):
""" Quick shortcut to ezt with strings """
tmpl = ezt.Template(template_file)
fp = ezt.StringIO()
tmpl.generate(fp, data)
return fp.getvalue()
def _runTemplateFile(self, path, data):
t = ezt.Template('ezt_test_data/' + path)
o = StringIO.StringIO()
t.generate(o, data)
return o.getvalue()
def _runTemplate(self, template, data, fmt=ezt.FORMAT_RAW):
t = ezt.Template()
t.parse(template, base_format=fmt)
o = StringIO.StringIO()
t.generate(o, data)
return o.getvalue()
def write(self):
install_deps = self.graph.get_deps(gen_base.DT_INSTALL)
install_sources = self.graph.get_all_sources(gen_base.DT_INSTALL)
cp = configparser.ConfigParser()
cp.read('gen-make.opts')
if cp.has_option('options', '--installed-libs'):
self.installed_libs = cp.get('options',
'--installed-libs').split(',')
else:
self.installed_libs = []
# ensure consistency between runs
install_deps.sort()
install_sources.sort(key=lambda s: s.name)
class _eztdata(object):
def __init__(self, **kw):
vars(self).update(kw)
data = _eztdata(
modules=[],
swig_langs=[],
swig_c=[],
target=[],
itargets=[],
areas=[],
isources=[],
deps=[],
sql=[],
)
########################################
for target in install_sources:
if isinstance(target, gen_base.TargetRaModule) or \
isinstance(target, gen_base.TargetFsModule):
# name of the module: strip 'libsvn_' and upper-case it
name = target.name[7:].upper()
# construct a list of the other .la libs to link against
retreat = build_path_retreat(target.path)
if target.name in self.installed_libs:
deps = []
link = ['-l%s-%s' % (target.name[3:], self.version)]
else:
deps = [target.filename]
link = [build_path_join(retreat, target.filename)]
for source in self.graph.get_sources(gen_base.DT_LINK,
target.name):
if not isinstance(
source, gen_base.TargetLib) or source.external_lib:
continue
elif source.name in self.installed_libs:
continue
deps.append(source.filename)
link.append(build_path_join(retreat, source.filename))
data.modules.append(_eztdata(name=name, deps=deps, link=link))
# write a list of directories in which things are built
# get all the test scripts' directories
script_dirs = list(
map(build_path_dirname, self.scripts + self.bdb_scripts))
# remove duplicate directories between targets and tests
build_dirs = unique(self.target_dirs + script_dirs + self.swig_dirs)
data.build_dirs = build_dirs
# write lists of test files
# deps = all, progs = not including those marked "testing = skip"
data.bdb_test_deps = self.bdb_test_deps + self.bdb_scripts
data.bdb_test_progs = self.bdb_test_progs + self.bdb_scripts
data.test_deps = self.test_deps + self.scripts
data.test_progs = self.test_progs + self.scripts
data.test_helpers = self.test_helpers
# write list of all manpages
data.manpages = self.manpages
# write a list of files to remove during "make clean"
cfiles = []
for target in install_sources:
# .la files are handled by the standard 'clean' rule; clean all the
# other targets
if not isinstance(target, gen_base.TargetScript) \
and not isinstance(target, gen_base.TargetProject) \
and not isinstance(target, gen_base.TargetI18N) \
and not isinstance(target, gen_base.TargetJava) \
and not target.external_lib \
and target.filename[-3:] != '.la':
cfiles.append(target.filename)
for script in self.scripts:
if script.endswith('.py'):
cfiles.append(script + 'c')
data.cfiles = sorted(cfiles)
# here are all the SQL files and their generated headers. the Makefile
# has an implicit rule for generating these, so there isn't much to do
# except to clean them out. we only do that for 'make extraclean' since
# these are included as part of the tarball. the files are transformed
# by gen-make, and developers also get a Make rule to keep them updated.
for hdrfile, sqlfile in sorted(self.graph.get_deps(gen_base.DT_SQLHDR),
key=lambda t: t[0]):
data.sql.append(_eztdata(header=hdrfile, source=sqlfile[0]))
data.release_mode = ezt.boolean(self.release_mode)
########################################
if not self.release_mode:
swig_rules = StringIO()
for swig in (generator.swig.header_wrappers,
generator.swig.checkout_swig_header,
generator.swig.external_runtime):
gen = swig.Generator(self.conf, "swig")
gen.write_makefile_rules(swig_rules)
data.swig_rules = swig_rules.getvalue()
########################################
# write dependencies and build rules for generated .c files
swig_c_deps = sorted(self.graph.get_deps(gen_base.DT_SWIG_C),
key=lambda t: t[0].filename)
swig_lang_deps = {}
for lang in self.swig.langs:
swig_lang_deps[lang] = []
for objname, sources in swig_c_deps:
swig_lang_deps[objname.lang].append(str(objname))
for lang in self.swig.langs:
data.swig_langs.append(
_eztdata(name=lang,
short=self.swig.short[lang],
short_upper=self.swig.short[lang].upper(),
deps=swig_lang_deps[lang]))
########################################
if not self.release_mode:
for objname, sources in swig_c_deps:
data.swig_c.append(
_eztdata(c_file=str(objname),
deps=list(map(str, sources)),
opts=self.swig.opts[objname.lang],
source=str(sources[0])))
########################################
for target_ob in install_sources:
if isinstance(target_ob, gen_base.TargetScript):
# there is nothing to build
continue
target = target_ob.name
if isinstance(target_ob, gen_base.TargetJava):
path = target_ob.output_dir
else:
path = target_ob.path
retreat = build_path_retreat(path)
# get the source items (.o and .la) for the link unit
objects = []
objdeps = []
object_srcs = []
headers = []
header_classes = []
header_class_filenames = []
deps = []
libs = []
add_deps = target_ob.add_deps.split()
for link_dep in self.graph.get_sources(gen_base.DT_LINK,
target_ob.name):
if isinstance(link_dep, gen_base.TargetJava):
deps.append(link_dep.name)
elif isinstance(link_dep, gen_base.TargetLinked):
if link_dep.external_lib:
libs.append(link_dep.external_lib)
elif link_dep.external_project:
# FIXME: This is a temporary workaround to fix build breakage
# expeditiously. It is of questionable validity for a build
# node to have external_project but not have external_lib.
pass
elif link_dep.name in self.installed_libs:
libs.append('-l%s-%s' %
(link_dep.name[3:], self.version))
else:
# append the output of the target to our stated dependencies
if not self.assume_shared_libs:
deps.append(link_dep.filename)
# link against the library
libs.append(build_path_join(retreat,
link_dep.filename))
elif isinstance(link_dep, gen_base.ObjectFile):
# link in the object file
objects.append(link_dep.filename)
objdeps.append(_normstr(link_dep.filename))
for dep in self.graph.get_sources(gen_base.DT_OBJECT,
link_dep,
gen_base.SourceFile):
object_srcs.append(
build_path_join('$(abs_srcdir)', dep.filename))
elif isinstance(link_dep, gen_base.HeaderFile):
# link in the header file
# N.B. that filename_win contains the '_'-escaped class name
headers.append(link_dep.filename_win)
header_classes.append(link_dep.classname)
for dep in self.graph.get_sources(gen_base.DT_OBJECT,
link_dep,
gen_base.ObjectFile):
header_class_filenames.append(dep.filename)
else:
### we don't know what this is, so we don't know what to do with it
raise UnknownDependency
for nonlib in self.graph.get_sources(gen_base.DT_NONLIB,
target_ob.name):
if isinstance(nonlib, gen_base.TargetLinked):
if not nonlib.external_lib:
deps.append(nonlib.filename)
targ_varname = target.replace('-', '_')
objnames = build_path_strip(path, objects)
ezt_target = _eztdata(
name=target_ob.name,
varname=targ_varname,
path=path,
install=None,
add_deps=add_deps,
objects=objects,
objdeps=objdeps,
deps=deps,
when=target_ob.when,
)
data.target.append(ezt_target)
if hasattr(target_ob, 'link_cmd'):
ezt_target.link_cmd = target_ob.link_cmd
if hasattr(target_ob, 'output_dir'):
ezt_target.output_dir = target_ob.output_dir
if hasattr(target_ob, 'headers_dir'):
ezt_target.headers_dir = target_ob.headers_dir
# Add additional install dependencies if necessary
if target_ob.add_install_deps:
ezt_target.install = target_ob.install
ezt_target.install_deps = target_ob.add_install_deps
if isinstance(target_ob, gen_base.TargetJava):
ezt_target.type = 'java'
ezt_target.headers = headers
ezt_target.sources = None
ezt_target.jar = None
ezt_target.classes = target_ob.classes
# Build the headers from the header_classes with one 'javah' call
if headers:
ezt_target.header_class_filenames = header_class_filenames
ezt_target.header_classes = header_classes
# Build the objects from the object_srcs with one 'javac' call
if object_srcs:
ezt_target.sources = object_srcs
# Once the bytecodes have been compiled up, we produce the
# JAR.
if target_ob.jar:
ezt_target.jar_path = build_path_join(
target_ob.classes, target_ob.jar)
ezt_target.packages = target_ob.packages
elif isinstance(target_ob, gen_base.TargetI18N):
ezt_target.type = 'i18n'
else:
ezt_target.type = 'n/a'
ezt_target.filename = target_ob.filename
ezt_target.path = path
if (isinstance(target_ob, gen_base.TargetLib)
and not target_ob.undefined_lib_symbols):
ezt_target.undefined_flag = '$(LT_NO_UNDEFINED)'
else:
ezt_target.undefined_flag = ''
ezt_target.libs = gen_base.unique(libs)
ezt_target.objnames = objnames
ezt_target.basename = build_path_basename(target_ob.filename)
########################################
for itype, i_targets in install_deps:
# perl bindings do their own thing, "swig-pl" target is
# already specified in Makefile.in
if itype == "swig-pl":
continue
outputs = []
for t in i_targets:
if hasattr(t, 'filename'):
outputs.append(t.filename)
data.itargets.append(_eztdata(type=itype, outputs=outputs))
########################################
# for each install group, write a rule to install its outputs
for area, inst_targets in install_deps:
# perl bindings do their own thing, "install-swig-pl" target is
# already specified in Makefile.in
if area == "swig-pl":
continue
# get the output files for these targets, sorted in dependency order
files = gen_base._sorted_files(self.graph, area)
ezt_area_type = (area == 'apache-mod' and 'mods-shared' or area)
ezt_area = _eztdata(type=ezt_area_type,
files=[],
extra_install=None)
def file_to_eztdata(file):
# cd to dirname before install to work around libtool 1.4.2 bug.
dirname, fname = build_path_splitfile(file.filename)
return _eztdata(
mode=None,
dirname=dirname,
fullname=file.filename,
filename=fname,
when=file.when,
pc_fullname=None,
pc_installdir=None,
pc_install_fname=None,
)
def apache_file_to_eztdata(file):
# cd to dirname before install to work around libtool 1.4.2 bug.
dirname, fname = build_path_splitfile(file.filename)
base, ext = os.path.splitext(fname)
name = base.replace('mod_', '')
return _eztdata(mode='apache-mod',
fullname=file.filename,
dirname=dirname,
name=name,
filename=fname,
when=file.when)
if area != 'test' and area != 'bdb-test':
data.areas.append(ezt_area)
area_var = area.replace('-', '_')
upper_var = area_var.upper()
ezt_area.varname = area_var
ezt_area.uppervar = upper_var
for file in files:
if isinstance(file.target, gen_base.TargetApacheMod):
ezt_file = apache_file_to_eztdata(file)
else:
ezt_file = file_to_eztdata(file)
if area == 'locale':
lang, objext = os.path.splitext(ezt_file.filename)
installdir = ('$(DESTDIR)$(%sdir)/%s/LC_MESSAGES' %
(area_var, lang))
ezt_file.installdir = installdir
ezt_file.objext = objext
else:
ezt_file.install_fname = build_path_join(
'$(%sdir)' % area_var, ezt_file.filename)
# Install pkg-config files
if (isinstance(file.target, gen_base.TargetLib)
and ezt_file.fullname.startswith(
'subversion/libsvn_')):
ezt_file.pc_fullname = ezt_file.fullname.replace(
'-1.la', '.pc')
ezt_file.pc_installdir = '$(pkgconfig_dir)'
pc_install_fname = ezt_file.filename.replace(
'-1.la', '.pc')
ezt_file.pc_install_fname = build_path_join(
ezt_file.pc_installdir, pc_install_fname)
ezt_area.files.append(ezt_file)
# certain areas require hooks for extra install rules defined
# in Makefile.in
### we should turn AREA into an object, then test it instead of this
if area[:5] == 'swig-' and area[-4:] != '-lib' \
or area[:7] == 'javahl-' \
or area[:6] == 'svnxx-' \
or area == 'tools':
ezt_area.extra_install = 'yes'
########################################
includedir = build_path_join('$(includedir)',
'subversion-%s' % self.version)
data.includes = [
_eztdata(file=file,
src=build_path_join('$(abs_srcdir)', file),
dst=build_path_join(includedir,
build_path_basename(file)))
for file in self.includes
]
data.includedir = includedir
########################################
for target in install_sources:
if not isinstance(target, gen_base.TargetScript) and \
not isinstance(target, gen_base.TargetJava) and \
not isinstance(target, gen_base.TargetI18N):
data.isources.append(
_eztdata(name=target.name, filename=target.filename))
########################################
# write dependencies and build rules (when not using suffix rules)
# for all other generated files which will not be installed
# (or will be installed, but not by the main generated build)
obj_deps = sorted(self.graph.get_deps(gen_base.DT_OBJECT),
key=lambda t: t[0].filename)
for objname, sources in obj_deps:
dep = _eztdata(name=_normstr(objname),
when=objname.when,
deps=list(map(_normstr, sources)),
cmd=objname.compile_cmd,
source=_normstr(sources[0]))
data.deps.append(dep)
dep.generated = ezt.boolean(getattr(objname, 'source_generated',
0))
template = ezt.Template(os.path.join('build', 'generator', 'templates',
'build-outputs.mk.ezt'),
compress_whitespace=False)
template.generate(open('build-outputs.mk', 'w'), data)
self.write_standalone()
self.write_transform_libtool_scripts(install_sources)
self.write_pkg_config_dot_in_files(install_sources)
#!/usr/bin/env python
"""runezt.py -- stub for ezt.py"""
import ezt
if __name__ == '__main__':
import sys
for filename in sys.argv[1:]:
template = ezt.Template(filename)
template.generate(sys.stdout, {})
#!/usr/bin/env python
import sys
sys.path.insert(0, '..')
import ezt
class _item:
pass
t = ezt.Template('test.ezt')
nonseq = _item()
nonseq.attr = 'nonseq.attr'
seqitem = _item()
seqitem.attr = 'seqitem.attr'
nonseq.seq = [seqitem, seqitem]
data = {
'nonseq': nonseq,
'sensitive': '<cool & stuff>',
}
t.generate(sys.stdout, data)
# do it with an attribute-based object now.
data2 = _item()
vars(data2).update(data)
def __init__(self, fname):
EdnaRequestHandler.protocol_version = "HTTP/1.1"
self.userLog = [] # to track server usage
self.userIPs = {} # log unique IPs
config = self.config = ConfigParser.ConfigParser()
config.add_section('server')
config.add_section('sources')
config.add_section('acl')
config.add_section('extra')
# set up some defaults for the web server.
d = config.defaults()
d['port'] = '8080'
d['robots'] = '1'
d['binding-hostname'] = ''
d['name_prefix'] = ''
d['log'] = ''
d['template-dir'] = 'templates'
d['template'] = 'default.ezt'
d['resource-dir'] = 'resources'
d['auth_level'] = '1'
d['debug_level'] = '0'
d['fileinfo'] = '0'
d['encoding'] = 'UTF-8,iso8859-1'
d['hide_names'] = ""
d['hide_matching'] = ""
d['zip'] = '0'
config.read(fname)
# Setup a logging file
self.log = None
log = self.config.get('server', 'log')
if log:
if log == '-':
self.log = sys.stdout
else:
try:
self.log = open(log, 'a')
except IOError:
pass
template_path = config.get('server', 'template-dir')
template_file = config.get('server', 'template')
template_path = os.path.join(os.path.dirname(fname), template_path)
self.resource_dir = os.path.join(os.path.dirname(fname),
config.get('server', 'resource-dir'))
self.fileinfo = config.getint('server', 'fileinfo')
self.zipmax = config.getint('server', 'zip') * 1024 * 1024
self.zipsize = 0
global debug_level
debug_level = config.getint('extra', 'debug_level')
global DAYS_NEW
DAYS_NEW = config.getint('extra', 'days_new')
global HIDE_EXACT
HIDE_EXACT = filter(None, [
toHide.strip().lower()
for toHide in config.get('extra', 'hide_names').split(',')
])
global HIDE_MATCH
HIDE_MATCH = filter(None, [
toHide.strip().lower()
for toHide in config.get('extra', 'hide_matching').split(',')
])
if debug_level == 1:
self.log_message('Running in debug mode')
encodings = string.split(config.get('server', 'encoding'), ',')
tfname = os.path.join(template_path, template_file)
self.default_template = ezt.Template(tfname, encodings)
tfname = os.path.join(template_path, 'style-xml.ezt')
self.xml_template = ezt.Template(tfname, encodings)
tfname = os.path.join(template_path, 'stats.ezt')
self.stats_template = ezt.Template(tfname, encodings)
self.dirs = []
dirs = []
for option in config.options('sources'):
if option[:3] == 'dir':
dirs.append((int(option[3:]), config.get('sources', option)))
if not dirs:
raise error, 'no sources'
dirs.sort()
for i in range(len(dirs)):
dir = map(string.strip, string.split(dirs[i][1], '='))
if len(dir) == 1:
name = dir[0]
else:
name = dir[1]
if not os.path.isdir(dir[0]):
self.log_message("WARNING: a source's directory must exist")
self.log_message(" skipping: dir%d = %s = %s" %
(dirs[i][0], dir[0], name))
continue
if string.find(name, '/') != -1:
self.log_message(
"WARNING: a source's display name cannot contain '/'")
self.log_message(" skipping: dir%d = %s = %s" %
(dirs[i][0], dir[0], name))
continue
self.dirs.append((dir[0], name))
self.acls = []
try:
allowed = re.split(r'[\s\n,]+', config.get('acl', 'allow'))
except ConfigParser.NoOptionError:
allowed = []
for addr in allowed:
if '/' in addr:
addr, masklen = string.split(addr, '/')
masklen = int(masklen)
else:
masklen = 32
if not re.match(r'^\d+\.\d+\.\d+\.\d+$', addr):
addr = socket.gethostbyname(addr)
mask = ~((1 << (32 - masklen)) - 1)
entry = (dot2int(addr), mask)
if not entry in self.acls:
self.acls.append(entry)
try:
auth_pairs = re.split(r'[\s\n,]+', config.get('acl', 'auth'))
self.auth_table = {}
try:
self.password_hash = config.get('acl', 'password_hash')
if not globals().has_key(self.password_hash):
self.log_message("WARNING: there is no hash module '%s' for passwords" % \
self.password_hash)
self.password_hash = None
else:
self.debug_message("passwords authenticated using %s hexdigest" % \
self.password_hash)
except ConfigParser.NoOptionError:
self.password_hash = None
if self.password_hash is None:
self.debug_message("passwords authenticated in plain text")
for pair in auth_pairs:
user, passw = string.split(pair, ':')
self.auth_table[user] = passw
except ConfigParser.NoOptionError:
self.auth_table = {}
self.auth_level = config.get('acl', 'auth_level')
self.name_prefix = config.get('server', 'name_prefix')
self.port = config.getint('server', 'port')
try:
SocketServer.TCPServer.__init__(
self, (config.get('server', 'binding-hostname'), self.port),
EdnaRequestHandler)
except socket.error, value:
self.log_message("edna: bind(): %s" % str(value[1]))
raise SystemExit
#! /usr/bin/env python
import xml.dom.minidom
import os
import stat
import re
from cStringIO import StringIO
import sys
import ezt
base_template = ezt.Template()
base_template.parse(file('templates/base.ezt').read())
buildlog_template = ezt.Template()
buildlog_template.parse(file('templates/buildlog.ezt').read())
changelog_template = ezt.Template()
changelog_template.parse(file('templates/changelog.ezt').read())
tests_template = ezt.Template()
tests_template.parse(file('templates/tests.ezt').read())
def getText(nodelist):
if not nodelist:
return None
rc = ''
for node in nodelist:
if node.nodeType == node.TEXT_NODE:
rc = rc + node.data
return rc.encode('utf-8')
class ChangelogFile:
if not lang[0].isalpha() or not lang[1].isalpha():
raise Exception("Error: Invalid language code: must be alphabetic.\n")
if not os.path.isdir(lang):
raise Exception("Error: Invalid language code: " \
"we don't support '%s'\n" % lang)
proc = subprocess.Popen([
"echo -n 'Build started '; " + "date; " + "echo; " +
"make %s 2>&1; " % lang + "echo; " +
"echo 'Please check the sizes and dates on the result files:'; " +
"echo;" +
"echo -n ' '; ls -g -G -h -l --time-style='+%%a %%b %%e %%T %%Z %%Y' %s/index.html | cut -d ' ' -f 3-; "
% lang +
"echo -n ' '; ls -g -G -h -l --time-style='+%%a %%b %%e %%T %%Z %%Y' %s/producingoss.html | cut -d ' ' -f 3-; "
% lang +
"echo -n ' '; ls -g -G -h -l --time-style='+%%a %%b %%e %%T %%Z %%Y' %s/producingoss.pdf | cut -d ' ' -f 3-; "
% lang + "echo;" + "echo -n 'Build finished '; " + "date; "
],
stdout=subprocess.PIPE,
shell=True)
(out, err) = proc.communicate()
ezt_template = ezt.Template("rebuild.ezt")
ezt_data = {
'lang': lang,
'out': out,
'err': err,
}
print "Content-type: text/html\n\n"
ezt_template.generate(sys.stdout, ezt_data)
def generate():
template = ezt.Template(TEMPLATE, compress_whitespace=False)
template.generate(sys.stdout, prepare_data())
