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())