#!/usr/bin/env python  """ A setup and configuration script for MoinMoin.  Copyright (C) 2010, 2011 Paul Boddie <paul@boddie.org.uk>  This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.  You should have received a copy of the GNU General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>. """  from os.path import abspath, exists, extsep, isdir, join, normpath, split from getpass import getpass from glob import glob from zipfile import ZipFile import os import sys import shutil import re import tempfile  __version__ = "0.3"  # Regular expressions for editing MoinMoin scripts and configuration files.  def compile_definition(name):     return re.compile(r"^(\s*)#*\s*(%s =)\s*(.*)$" % name, re.MULTILINE)  wikiconfig_import        = re.compile(r"^(\s*)#*\s*"                             r"(from\s+)(?P<module>\S+)"                             r"(\s+import\s+)(?P<names>(?:\S|[^,\s])+(?:\s*,\s*(?:\S|[^,\s])+)*)"                             r"(\s*)$", re.MULTILINE)  moin_cgi_prefix          = re.compile(r"^#sys\.path\.insert\(0, 'PREFIX.*$", re.MULTILINE) moin_cgi_wikiconfig      = re.compile(r"^#sys\.path\.insert\(0, '/path/to/wikiconfigdir.*$", re.MULTILINE) moin_cgi_properties      = compile_definition("properties") moin_cgi_fix_script_name = compile_definition("fix_script_name") moin_cgi_force_cgi       = re.compile(r"^#(os.environ\['FCGI_FORCE_CGI'\].*)$", re.MULTILINE)  css_import_stylesheet    = re.compile(r"(\s*@import\s+[\"'])(.*?)([\"']\s*;)")  # Templates for Apache site definitions.  apache_site = """ ScriptAlias %(url_path)s "%(web_app_dir)s/moin.cgi" """  apache_site_extra_moin18 = """ Alias %(static_url_path)s "%(htdocs_dir)s/" """  # Limited hosting .htaccess definitions require the following settings to be # configured in the main Apache configuration files: # # Options ExecCGI FollowSymLinks Indexes SymLinksIfOwnerMatch # AllowOverride FileInfo Limit # AddHandler cgi-script .cgi  apache_htaccess_combined_mod_rewrite = """ DirectoryIndex moin.cgi RewriteEngine On RewriteBase %(url_path)s RewriteCond %%{REQUEST_FILENAME} !-f RewriteCond %%{REQUEST_FILENAME} !-d RewriteRule ^(.*) moin.cgi/$1 [PT,L,QSA] """  # Post-setup templates.  postsetup_setfacl = """#!/bin/sh  find '%(conf_dir)s/data' -type f | xargs setfacl -m u:%(web_user)s:rw find '%(conf_dir)s/data' -type d | xargs setfacl -m u:%(web_user)s:rwx find '%(conf_dir)s/underlay' -type f | xargs setfacl -m u:%(web_user)s:rw find '%(conf_dir)s/underlay' -type d | xargs setfacl -m u:%(web_user)s:rwx """  postsetup_setfacl_moin18_extra = """ find '%(htdocs_dir)s' -type f | xargs setfacl -m u:%(web_user)s:r find '%(htdocs_dir)s' -type d | xargs setfacl -m u:%(web_user)s:rx """  postsetup_chown_chmod = """#!/bin/sh  chown -R %(this_user)s.%(web_group)s '%(conf_dir)s/data' chown -R %(this_user)s.%(web_group)s '%(conf_dir)s/underlay' chmod -R g+w '%(conf_dir)s/data' chmod -R g+w '%(conf_dir)s/underlay' """  postsetup_chown_moin18_extra = """ chown -R %(this_user)s.%(web_group)s '%(htdocs_dir)s' """  # Utility functions.  def readfile(filename):     f = open(filename)     try:         return f.read()     finally:         f.close()  def writefile(filename, s):     f = open(filename, "w")     try:         f.write(s)     finally:         f.close()  def status(message):     print message  note = status error = status  def format(s, indent):     return re.sub("\n\s+", "\n" + " " * indent, s)  # Classes.  class SetupException(Exception):      "An exception indicating a problem with a setup action."      pass  class Configuration:      "A class representing the configuration."      special_names = ["site_name"]      def __init__(self, filename):         self.content = readfile(filename)         self.filename = filename      def get_pattern(self, name):          # Make underscores optional for certain names.          if name in self.special_names:             name = name.replace("_", "_?")          return compile_definition(name)      def get(self, name):          """         Return the raw value of the last definition having the given 'name'.         """          pattern = self.get_pattern(name)         results = [match.group(3) for match in pattern.finditer(self.content)]         if results:             return results[-1]         else:             return None      def set(self, name, value, count=None, raw=0):          """         Set the configuration parameter having the given 'name' with the given         'value', limiting the number of appropriately named parameters changed         to 'count', if specified.          If the configuration parameter of the given 'name' does not exist,         insert such a parameter at the end of the file.          If the optional 'raw' parameter is specified and set to a true value,         the provided 'value' is inserted directly into the configuration file.         """          if not self.replace(name, value, count, raw):             self.insert(name, value, raw)      def replace(self, name, value, count=None, raw=0):          """         Replace configuration parameters having the given 'name' with the given         'value', limiting the number of appropriately named parameters changed         to 'count', if specified.          If the optional 'raw' parameter is specified and set to a true value,         the provided 'value' is inserted directly into the configuration file.          Return the number of substitutions made.         """          if raw:             substitution = r"\1\2 %s" % value         else:             substitution = r"\1\2 %r" % value          pattern = self.get_pattern(name)          if count is None:             self.content, n = pattern.subn(substitution, self.content)         else:             self.content, n = pattern.subn(substitution, self.content, count=count)          return n      def insert(self, name, value, raw=0):          """         Insert the configuration parameter having the given 'name' and 'value'.          If the optional 'raw' parameter is specified and set to a true value,         the provided 'value' is inserted directly into the configuration file.         """          if raw:             insertion = "%s = %s"         else:             insertion = "%s = %r"          self.insert_text(insertion % (name, value))      def insert_text(self, text):          "Insert the given 'text' at the end of the configuration."          if not self.content.endswith("\n"):             self.content += "\n"         self.content += "    %s\n" % text      def set_import(self, imported_module, imported_names):          """         Set up an import of the given 'imported_module' exposing the given         'imported_names'.         """          s = self.content         after_point = 0         first_point = None          for module_import in wikiconfig_import.finditer(s):             before, from_keyword, module, import_keyword, names, after = module_import.groups()             before_point, after_point = module_import.span()              if first_point is None:                 first_point = after_point              names = [name.strip() for name in names.split(",")]              # Test the import for a reference to the requested imported module.              if imported_module == module:                 for name in imported_names:                     if name not in names:                         names.append(name)                  self.content = s[:before_point] + (                     "%s%s%s%s%s%s" % (before, from_keyword, module, import_keyword, ", ".join(names), after)                     ) + s[after_point:]                 break          # Where no import references the imported module, insert a reference         # into the configuration.          else:             # Add the import after the first one.              if first_point is not None:                 self.content = s[:first_point] + ("\nfrom %s import %s" % (imported_module, ", ".join(imported_names))) + s[first_point:]      def close(self):          "Close the file, writing the content."          writefile(self.filename, self.content)  class Installation:      "A class for installing and initialising MoinMoin."      method_names = (         "setup",         "setup_wiki",         "install_moin",         "install_data",         "configure_moin",         "edit_moin_script",         "edit_moin_web_script",         "add_superuser",         "make_site_files",         "make_post_install_script",         "reconfigure_moin",         "set_auth_method",          # Post-installation activities.          "install_theme",         "install_extension_package",         "install_plugins",         "install_actions",         "install_macros",         "install_parsers",         "install_theme_resources",         "edit_theme_stylesheet",          # Other activities.          "make_page_package",         "install_page_package",         )      # NOTE: Need to detect Web server user.      web_user = "www-data"     web_group = "www-data"      # MoinMoin resources.      theme_master = "modernized"     extra_theme_css_files = ["SlideShow.css"]      def __init__(self, moin_distribution, moin_data, prefix, web_app_dir,         common_dir, url_path, superuser, site_name, front_page_name,         web_site_dir=None, web_static_dir=None, theme_default=None):          """         Initialise a Wiki installation using the following:            * moin_distribution - the directory containing a MoinMoin source                                 distribution           * moin_data         - the directory containing MoinMoin shared data                                 (can be omitted if 'moin_distribution' is given)           * prefix            - the installation prefix (equivalent to /usr)           * web_app_dir       - the directory where Web applications and scripts                                 reside (such as /home/www-user/cgi-bin)           * common_dir        - the directory where the Wiki configuration,                                 resources and instance will reside (such as                                 /home/www-user/mywiki)           * url_path          - the URL path at which the Wiki will be made                                 available (such as / or /mywiki)           * superuser         - the name of the site's superuser (such as                                 "AdminUser")           * site_name         - the name of the site (such as "My Wiki")           * front_page_name   - the front page name for the site (such as                                 "FrontPage" or a specific name for the site)           * web_site_dir      - optional: the directory where Web site                                 definitions reside (such as                                 /etc/apache2/sites-available)           * web_static_dir    - optional: the directory where static Web                                 resources reside (such as /home/www-user/htdocs)           * theme_default     - optional: the default theme (such as modern)         """          self.moin_distribution = moin_distribution         self.moin_data = moin_data         self.superuser = superuser         self.site_name = site_name         self.front_page_name = front_page_name         self.theme_default = theme_default          # NOTE: Support the detection of the Apache sites directory.          self.prefix, self.web_app_dir, self.web_site_dir, self.web_static_dir, self.common_dir = \             map(self._get_abspath, (prefix, web_app_dir, web_site_dir, web_static_dir, common_dir))          # Strip any trailing "/" from the URL path.          if url_path != "/" and url_path.endswith("/"):             self.url_path = url_path[:-1]         else:             self.url_path = url_path          # Define and create specific directories.         # Here are the configuration and actual Wiki data directories.          self.conf_dir = join(self.common_dir, "conf")         self.instance_dir = join(self.common_dir, "wikidata")          # Define the place where the MoinMoin package will actually reside.          self.prefix_site_packages = join(self.prefix, "lib", "python%s.%s" % sys.version_info[:2], "site-packages")          # Find the version.          self.moin_version = self.get_moin_version()          # The static resources reside in different locations depending on the         # version of MoinMoin. Moreover, these resources may end up in a         # published directory for 1.8 installations where the Web server cannot         # be instructed to fetch the content from outside certain designated         # locations.          # 1.9: moin/lib/python2.x/site-packages/MoinMoin/web/static/htdocs          if self.moin_version.startswith("1.9"):              # A shared data directory may be in use.              if self.moin_data:                 self.htdocs_dir = self.htdocs_dir_source = join(self.moin_data, "htdocs")             else:                 self.htdocs_dir = self.htdocs_dir_source = join(self.prefix_site_packages, "MoinMoin", "web", "static", "htdocs")              self.static_url_path = self.url_path          # 1.8: moin/share/moin/htdocs (optionally copied to a Web directory)          else:              # A shared data directory may be in use.              if self.moin_data:                 self.htdocs_dir_source = join(self.moin_data, "htdocs")             else:                 self.htdocs_dir_source = join(self.instance_dir, "share", "moin", "htdocs")              # Add the static identifier to the URL path. For example:             # /         -> /moin_static187             # /hgwiki   -> /hgwiki-moin_static187              self.static_url_path = self.url_path + (self.url_path != "/" and "-" or "") + self.get_static_identifier()              # In limited hosting, the static resources directory is related to             # the URL path.              if self.limited_hosting():                 self.htdocs_dir = join(self.web_static_dir or self.web_app_dir, self.static_url_path.lstrip("/"))              # Otherwise, a mapping is made to the directory.              else:                 self.htdocs_dir = self.htdocs_dir_source      def _get_abspath(self, d):         return d and abspath(d) or None      def get_moin_version(self):          "Inspect the MoinMoin package information, returning the version."          if self.moin_distribution:             try:                 this_dir = os.getcwd()                 try:                     os.chdir(self.moin_distribution)                     f = open("PKG-INFO")                     try:                         for line in f.xreadlines():                             columns = line.split()                             if columns[0] == "Version:":                                 return columns[1]                          return None                      finally:                         f.close()                  finally:                     os.chdir(this_dir)              except IOError:                 pass          # Where no distribution information can be read, try and import an         # installed version module.          f = os.popen("%s -c 'from MoinMoin.version import release; print release'" % sys.executable)         try:             return f.read().strip()         finally:             f.close()      def get_moin_data(self):          "Return the location of MoinMoin data."          return self.moin_data or self.moin_distribution and join(self.moin_distribution, "wiki") or None      def get_static_identifier(self):          "Return the static URL/directory identifier for the Wiki."          return "moin_static%s" % self.moin_version.replace(".", "")      def get_plugin_directory(self, plugin_type):          "Return the directory for plugins of the given 'plugin_type'."          data_dir = join(self.conf_dir, "data")         return join(data_dir, "plugin", plugin_type)      def limited_hosting(self):          "Return whether limited Web hosting is being used."          return not self.web_site_dir      def ensure_directories(self):          "Make sure that all the directories are available."          for d in (self.conf_dir, self.instance_dir, self.web_app_dir, self.web_static_dir, self.web_site_dir):             if d is not None and not exists(d):                 os.makedirs(d)      def get_theme_directories(self, theme_name=None):          """         Return tuples of the form (theme name, theme directory) for all themes,         or for a single theme if the optional 'theme_name' is specified.         """          filenames = theme_name and [theme_name] or os.listdir(self.htdocs_dir)         directories = []          for filename in filenames:             theme_dir = join(self.htdocs_dir, filename)              if not exists(theme_dir) or not isdir(theme_dir):                 continue              directories.append((filename, theme_dir))          return directories      # Main methods.      def setup(self):          "Set up the installation."          self.ensure_directories()         self.install_moin()         self._setup_wiki()      def setup_wiki(self):          "Set up a Wiki without installing MoinMoin."          self.ensure_directories()          try:             self.install_moin(data_only=1)         except SetupException:             if not self.moin_data:                 raise          self._setup_wiki()      def _setup_wiki(self):          "Set up a Wiki without installing MoinMoin."          self.install_data()         self.configure_moin()         self.edit_moin_script()         self.add_superuser()         self.edit_moin_web_script(self.make_site_files())         self.make_post_install_script()      def install_moin(self, data_only=0):          "Enter the distribution directory and run the setup script."          # NOTE: Possibly check for an existing installation and skip repeated         # NOTE: installation attempts.          if not self.moin_distribution:             raise SetupException, "Cannot install MoinMoin without a 'moin_distribution' setting being defined."          this_dir = os.getcwd()         os.chdir(self.moin_distribution)          log_filename = "install-%s.log" % split(self.common_dir)[-1]          status("Installing MoinMoin%s in %s..." % (data_only and " (data only)" or "", self.prefix))          if data_only:             install_cmd = "install_data"             options = "--install-dir='%s'" % self.instance_dir         else:             install_cmd = "install"             options = "--prefix='%s' --install-data='%s' --record='%s'" % (self.prefix, self.instance_dir, log_filename)          os.system("python setup.py --quiet %s %s --force" % (install_cmd, options))          os.chdir(this_dir)      def install_data(self):          "Install Wiki data."          moin_data = self.get_moin_data()          if not moin_data:             raise SetupException, \                 "Cannot install MoinMoin data without either a 'moin_distribution' or a 'moin_data' setting being defined."          # The default wikiconfig assumes data and underlay in the same directory.          status("Installing data and underlay in %s..." % self.conf_dir)          for d in ("data", "underlay"):             source = join(moin_data, d)             source_tar = source + os.path.extsep + "tar"             d_tar = source + os.path.extsep + "tar"              if os.path.exists(source):                 shutil.copytree(source, join(self.conf_dir, d))             elif os.path.exists(source_tar):                 shutil.copy(source_tar, self.conf_dir)                 os.system("tar xf %s -C %s" % (d_tar, self.conf_dir))             else:                 status("Could not copy %s into installed Wiki." % d)          # Copy static Web data if appropriate.          if not self.moin_version.startswith("1.9") and self.limited_hosting():              if not exists(self.htdocs_dir):                 os.mkdir(self.htdocs_dir)              for item in os.listdir(self.htdocs_dir_source):                 path = join(self.htdocs_dir_source, item)                 if isdir(path):                     shutil.copytree(path, join(self.htdocs_dir, item))                 else:                     shutil.copy(path, join(self.htdocs_dir, item))      def configure_moin(self):          "Edit the Wiki configuration file."          moin_data = self.get_moin_data()          if not moin_data:             raise SetupException, \                 "Cannot configure MoinMoin without either a 'moin_distribution' or a 'moin_data' setting being defined."          # NOTE: Single Wiki only so far.          # Static URLs seem to be different in MoinMoin 1.9.x.         # For earlier versions, reserve URL space alongside the Wiki.         # NOTE: MoinMoin usually uses an apparently common URL space associated         # NOTE: with the version, but more specific locations are probably         # NOTE: acceptable if less efficient.          if self.moin_version.startswith("1.9"):             url_prefix_static = "%r + url_prefix_static" % self.static_url_path         else:             url_prefix_static = "%r" % self.static_url_path          # Copy the Wiki configuration file from the distribution.          wikiconfig_py = join(self.conf_dir, "wikiconfig.py")         shutil.copyfile(join(moin_data, "config", "wikiconfig.py"), wikiconfig_py)          status("Editing configuration from %s..." % wikiconfig_py)          # Edit the Wiki configuration file.          wikiconfig = Configuration(wikiconfig_py)          try:             wikiconfig.set("url_prefix_static", url_prefix_static, raw=1)             wikiconfig.set("superuser", [self.superuser])             wikiconfig.set("acl_rights_before", u"%s:read,write,delete,revert,admin" % self.superuser)              if not self.moin_version.startswith("1.9"):                 data_dir = join(self.conf_dir, "data")                 data_underlay_dir = join(self.conf_dir, "underlay")                  wikiconfig.set("data_dir", data_dir)                 wikiconfig.set("data_underlay_dir", data_underlay_dir)              self._configure_moin(wikiconfig)          finally:             wikiconfig.close()      def _configure_moin(self, wikiconfig):          """         Configure Moin, accessing the configuration file using 'wikiconfig'.         """          wikiconfig.set("site_name", self.site_name)         wikiconfig.set("page_front_page", self.front_page_name, count=1)          if self.theme_default is not None:             wikiconfig.set("theme_default", self.theme_default)      def edit_moin_script(self):          "Edit the moin script."          moin_script = join(self.prefix, "bin", "moin")          status("Editing moin script at %s..." % moin_script)          s = readfile(moin_script)         s = s.replace("#import sys", "import sys\nsys.path.insert(0, %r)" % self.prefix_site_packages)          writefile(moin_script, s)      def edit_moin_web_script(self, site_file_configured=1):          "Edit and install CGI script."          # NOTE: CGI only so far.         # NOTE: Permissions should be checked.          moin_data = self.get_moin_data()          if self.moin_version.startswith("1.9"):             moin_cgi_script = "moin.fcgi"         else:             moin_cgi_script = "moin.cgi"          moin_cgi = join(moin_data, "server", moin_cgi_script)         moin_cgi_installed = join(self.web_app_dir, "moin.cgi")          status("Editing moin.cgi script from %s, writing to %s..." % (moin_cgi, moin_cgi_installed))          s = readfile(moin_cgi)         s = moin_cgi_prefix.sub("sys.path.insert(0, %r)" % self.prefix_site_packages, s)         s = moin_cgi_wikiconfig.sub("sys.path.insert(0, %r)" % self.conf_dir, s)          # Handle differences in script names when using limited hosting with         # URL rewriting.          if self.limited_hosting():             if not site_file_configured:                 note("Site file not configured: script name not changed.")             else:                 if self.moin_version.startswith("1.9"):                     s = moin_cgi_fix_script_name.sub(r"\1\2 %r" % self.url_path, s)                 else:                     s = moin_cgi_properties.sub(r"\1\2 %r" % {"script_name" : self.url_path}, s)          # NOTE: Use CGI for now.          if self.moin_version.startswith("1.9"):             s = moin_cgi_force_cgi.sub(r"\1", s)          writefile(moin_cgi_installed, s)         os.system("chmod a+rx '%s'" % moin_cgi_installed)      def add_superuser(self):          "Add the superuser account."          moin_script = join(self.prefix, "bin", "moin")          print "Creating superuser", self.superuser, "using..."         email = raw_input("E-mail address: ")         password = getpass("Password: ")          path = os.environ.get("PYTHONPATH", "")          if path:             os.environ["PYTHONPATH"] = path + ":" + self.conf_dir         else:             os.environ["PYTHONPATH"] = self.conf_dir          os.system(moin_script + " account create --name='%s' --email='%s' --password='%s'" % (self.superuser, email, password))          if path:             os.environ["PYTHONPATH"] = path         else:             del os.environ["PYTHONPATH"]      def make_site_files(self):          "Make the Apache site files."          # NOTE: Using local namespace for substitution.          # Where the site definitions and applications directories are different,         # use a normal site definition.          if not self.limited_hosting():              site_def = join(self.web_site_dir, self.site_name)              s = apache_site % self.__dict__              if not self.moin_version.startswith("1.9"):                 s += apache_site_extra_moin18 % self.__dict__              status("Writing Apache site definitions to %s..." % site_def)             writefile(site_def, s)              note("Copy the site definitions to the appropriate sites directory if appropriate.")             note("Then, make sure that the site is enabled by running the appropriate tools (such as a2ensite).")              return 1          # Otherwise, use an .htaccess file.          else:             site_def = join(self.web_app_dir, ".htaccess")              s = apache_htaccess_combined_mod_rewrite % self.__dict__              status("Writing .htaccess file to %s..." % site_def)             try:                 writefile(site_def, s)             except IOError:                 note("The .htaccess file could not be written. This will also affect the script name setting.")                 return 0             else:                 return 1      def make_post_install_script(self):          "Write a post-install script with additional actions."          # Work out whether setfacl works.          fd, temp_filename = tempfile.mkstemp(dir=self.conf_dir)         os.close(fd)          have_setfacl = os.system("setfacl -m user:%(web_user)s:r %(file)s > /dev/null 2>&1" % {             "web_user" : self.web_user, "file" : temp_filename}) == 0          os.remove(temp_filename)          # Create the scripts.          this_user = os.environ["USER"]         postinst_scripts = "moinsetup-post-chown.sh", "moinsetup-post-setfacl.sh"          vars = {}         vars.update(Installation.__dict__)         vars.update(self.__dict__)         vars.update(locals())          for postinst_script, start, extra in [             (postinst_scripts[0], postsetup_chown_chmod, postsetup_chown_moin18_extra),             (postinst_scripts[1], postsetup_setfacl, postsetup_setfacl_moin18_extra)             ]:              s = start % vars              if not self.moin_version.startswith("1.9"):                 s += extra % vars              writefile(postinst_script, s)             os.chmod(postinst_script, 0755)          if have_setfacl:             note("Run %s to set file ownership and permissions." % postinst_scripts[1])             note("If this somehow fails...")          note("Run %s as root to set file ownership and permissions." % postinst_scripts[0])      # Accessory methods.      def reconfigure_moin(self, name=None, value=None, raw=0):          """         Edit the installed Wiki configuration file, setting a parameter with any         given 'name' to the given 'value', treating the value as a raw         expression (not a string) if 'raw' is set to a true value.          If 'name' and the remaining parameters are omitted, the default         configuration activity is performed.         """          wikiconfig_py = join(self.conf_dir, "wikiconfig.py")          status("Editing configuration from %s..." % wikiconfig_py)          wikiconfig = Configuration(wikiconfig_py)          try:             # Perform default configuration.              if name is None and value is None:                 self._configure_moin(wikiconfig)             else:                 wikiconfig.set(name, value, raw=raw)          finally:             wikiconfig.close()      def set_auth_method(self, method_name):          """         Edit the installed Wiki configuration file, configuring the         authentication method having the given 'method_name'.         """          wikiconfig_py = join(self.conf_dir, "wikiconfig.py")          status("Editing configuration from %s..." % wikiconfig_py)          wikiconfig = Configuration(wikiconfig_py)          try:             # OpenID authentication.              if method_name.lower() == "openid":                 wikiconfig.set_import("MoinMoin.auth.openidrp", ["OpenIDAuth"])                  if self.moin_version.startswith("1.9"):                     if wikiconfig.get("cookie_lifetime"):                         wikiconfig.replace("cookie_lifetime", "(12, 12)", raw=1)                     else:                         wikiconfig.set("cookie_lifetime", "(12, 12)", raw=1)                 else:                     if wikiconfig.get("anonymous_session_lifetime"):                         wikiconfig.replace("anonymous_session_lifetime", "1000", raw=1)                     else:                         wikiconfig.set("anonymous_session_lifetime", "1000", raw=1)                  auth_object = "OpenIDAuth()"              # Default Moin authentication.              elif method_name.lower() in ("moin", "default"):                 wikiconfig.set_import("MoinMoin.auth", ["MoinAuth"])                 auth_object = "MoinAuth()"              # REMOTE_USER authentication.              elif method_name.lower() in ("given", "remote-user"):                 wikiconfig.set_import("MoinMoin.auth.http", ["HTTPAuth"])                 auth_object = "HTTPAuth(autocreate=True)"              # Other methods are not currently supported.              else:                 return              # Edit the authentication setting.              auth = wikiconfig.get("auth")             if auth:                 wikiconfig.replace("auth", "%s + [%s]" % (auth, auth_object), raw=1)             else:                 wikiconfig.set("auth", "[%s]" % auth_object, raw=1)          finally:             wikiconfig.close()      def install_theme(self, theme_dir, theme_name=None):          """         Install Wiki theme provided in the given 'theme_dir' having the given         optional 'theme_name' (if different from the 'theme_dir' name).         """          theme_dir = normpath(theme_dir)         theme_name = theme_name or split(theme_dir)[-1]         theme_module = join(theme_dir, theme_name + extsep + "py")          plugin_theme_dir = self.get_plugin_directory("theme")          # Copy the theme module.          status("Copying theme module to %s..." % plugin_theme_dir)          shutil.copy(theme_module, plugin_theme_dir)          # Copy the resources.          resources_dir = join(self.htdocs_dir, theme_name)          if not exists(resources_dir):             os.mkdir(resources_dir)          status("Copying theme resources to %s..." % resources_dir)          for d in ("css", "img"):             target_dir = join(resources_dir, d)             if exists(target_dir):                 status("Replacing %s..." % target_dir)                 shutil.rmtree(target_dir)             shutil.copytree(join(theme_dir, d), target_dir)          # Copy additional resources from other themes.          resources_source_dir = join(self.htdocs_dir, self.theme_master)         target_dir = join(resources_dir, "css")          status("Copying resources from %s..." % resources_source_dir)          for css_file in self.extra_theme_css_files:             css_file_path = join(resources_source_dir, "css", css_file)             if exists(css_file_path):                 shutil.copy(css_file_path, target_dir)          note("Don't forget to add theme resources for extensions for this theme.")         note("Don't forget to edit this theme's stylesheets for extensions.")      def install_extension_package(self, extension_dir):          "Install any libraries from 'extension_dir' using a setup script."          this_dir = os.getcwd()         os.chdir(extension_dir)         os.system("python setup.py install --prefix=%s" % self.prefix)         os.chdir(this_dir)      def install_plugins(self, plugins_dir, plugin_type):          """         Install Wiki actions provided in the given 'plugins_dir' of the         specified 'plugin_type'.         """          plugin_target_dir = self.get_plugin_directory(plugin_type)          # Copy the modules.          status("Copying %s modules to %s..." % (plugin_type, plugin_target_dir))          for module in glob(join(plugins_dir, "*%spy" % extsep)):             shutil.copy(module, plugin_target_dir)      def install_actions(self, actions_dir):          "Install Wiki actions provided in the given 'actions_dir'."          self.install_plugins(actions_dir, "action")      def install_macros(self, macros_dir):          "Install Wiki macros provided in the given 'macros_dir'."          self.install_plugins(macros_dir, "macro")      def install_parsers(self, parsers_dir):          "Install Wiki macros provided in the given 'parsers_dir'."          self.install_plugins(parsers_dir, "parser")      def install_theme_resources(self, theme_resources_dir, theme_name=None):          """         Install theme resources provided in the given 'theme_resources_dir'. If         a specific 'theme_name' is given, only that theme will be given the         specified resources.         """          for theme_name, theme_dir in self.get_theme_directories(theme_name):              # Copy the resources.              copied = 0              for d in ("css", "img"):                 source_dir = join(theme_resources_dir, d)                 target_dir = join(theme_dir, d)                  if not exists(target_dir):                     continue                  for resource in glob(join(source_dir, "*%s*" % extsep)):                     shutil.copy(resource, target_dir)                     copied = 1              if copied:                 status("Copied theme resources into %s..." % theme_dir)          note("Don't forget to edit theme stylesheets for any extensions.")      def edit_theme_stylesheet(self, theme_stylesheet, imported_stylesheet, action="ensure", theme_name=None):          """         Edit the given 'theme_stylesheet', ensuring (or removing) a reference to         the 'imported_stylesheet' according to the given 'action' (optional,         defaulting to "ensure"). If a specific 'theme_name' is given, only that         theme will be affected.         """          if action == "ensure":             ensure = 1         elif action == "remove":             ensure = 0         else:             error("Action %s not valid: it must be given as either 'ensure' or 'remove'." % action)             return          for theme_name, theme_dir in self.get_theme_directories(theme_name):              # Locate the resources.              css_dir = join(theme_dir, "css")              if not exists(css_dir):                 continue              theme_stylesheet_filename = join(css_dir, theme_stylesheet)             imported_stylesheet_filename = join(css_dir, imported_stylesheet)              if not exists(theme_stylesheet_filename):                 error("Stylesheet %s not defined in theme %s." % (theme_stylesheet, theme_name))                 continue              if not exists(imported_stylesheet_filename):                 error("Stylesheet %s not defined in theme %s." % (imported_stylesheet, theme_name))                 continue              # Edit the resources.              s = readfile(theme_stylesheet_filename)             after_point = 0              for stylesheet_import in css_import_stylesheet.finditer(s):                 before, filename, after = stylesheet_import.groups()                 before_point, after_point = stylesheet_import.span()                  # Test the import for a reference to the requested imported                 # stylesheet.                  if filename == imported_stylesheet:                     if ensure:                         break                     else:                         if s[after_point:after_point+1] == "\n":                             after_point += 1                         s = "%s%s" % (s[:before_point], s[after_point:])                          status("Removing %s from %s in theme %s..." % (imported_stylesheet, theme_stylesheet, theme_name))                         writefile(theme_stylesheet_filename, s)                         break              # Where no import references the imported stylesheet, insert a             # reference into the theme stylesheet.              else:                 if ensure:                      # Assume that the stylesheet can follow other imports.                      if s[after_point:after_point+1] == "\n":                         after_point += 1                     s = "%s%s\n%s" % (s[:after_point], '@import "%s";' % imported_stylesheet, s[after_point:])                      status("Adding %s to %s in theme %s..." % (imported_stylesheet, theme_stylesheet, theme_name))                     writefile(theme_stylesheet_filename, s)      def make_page_package(self, page_directory, package_filename):          """         Make a package containing the pages in 'page_directory', using the         filenames as the page names, and writing the package to a file with the         given 'package_filename'.         """          package = ZipFile(package_filename, "w")          try:             script = ["MoinMoinPackage|1"]              for filename in os.listdir(page_directory):                 pathname = join(page_directory, filename)                  # Add files as pages having the filename as page name.                  if os.path.isfile(pathname):                     package.write(pathname, filename)                     script.append("AddRevision|%s|%s" % (filename, filename))                  # Add directories ending with "-attachments" as collections of                 # attachments for a particular page.                  elif os.path.isdir(pathname) and filename.endswith("-attachments"):                     parent = filename[:-len("-attachments")]                      # Add each file as an attachment.                      for attachment in os.listdir(pathname):                         zipname = "%s_%s" % (filename, attachment)                         package.write(join(pathname, attachment), zipname)                         script.append("AddAttachment|%s|%s|%s||" % (zipname, attachment, parent))              package.writestr("MOIN_PACKAGE", "\n".join(script))          finally:             package.close()      def install_page_package(self, package_filename):          """         Install a package from the file with the given 'package_filename'.         """          path = os.environ.get("PYTHONPATH", "")          if path:             os.environ["PYTHONPATH"] = path + ":" + self.prefix_site_packages + ":" + self.conf_dir         else:             os.environ["PYTHONPATH"] = self.prefix_site_packages + ":" + self.conf_dir          installer = join(self.prefix_site_packages, "MoinMoin", "packages.py")         os.system("python %s i %s" % (installer, package_filename))          if path:             os.environ["PYTHONPATH"] = path         else:             del os.environ["PYTHONPATH"]  def show_methods():     print "Methods:"     print     for method_name in Installation.method_names:         doc = getattr(Installation, method_name).__doc__.strip()         print "%-30s%-s" % (method_name, format(doc, 30))     print  # Command line option syntax.  syntax_description = "[ -f <config-filename> ] ( <method> | --method=METHOD ) [ <method-argument> ... ]"  # Main program.  if __name__ == "__main__":     from ConfigParser import ConfigParser     import sys, cmdsyntax      # Check the command syntax.      syntax = cmdsyntax.Syntax(syntax_description)     try:         matches = syntax.get_args(sys.argv[1:])         args = matches[0]     except IndexError:         print "Syntax:"         print sys.argv[0], syntax_description         print         show_methods()         sys.exit(1)      # Obtain configuration details.      try:         config_filename = args.get("config-filename", "moinsetup.cfg")         config = ConfigParser()         config.read(config_filename)          # Obtain as many arguments as needed from the configuration.          config_arguments = dict(config.items("installation") + config.items("site"))         method_arguments = args.get("method-argument", [])          # Attempt to initialise the configuration.          installation = Installation(**config_arguments)      except TypeError:         print "Configuration settings:"         print         print Installation.__init__.__doc__         print         sys.exit(1)      # Obtain the method.      try:         method = getattr(installation, args["method"])     except AttributeError:         show_methods()         sys.exit(1)      try:         method(*method_arguments)     except TypeError:         print "Method documentation:"         print         print method.__doc__         print         raise  # vim: tabstop=4 expandtab shiftwidth=4