#!/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 = """ 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 '%(common_dir)s/data' -type f | xargs setfacl -m u:%(web_user)s:rw find '%(common_dir)s/data' -type d | xargs setfacl -m u:%(web_user)s:rwx find '%(common_dir)s/underlay' -type f | xargs setfacl -m u:%(web_user)s:rw find '%(common_dir)s/underlay' -type d | xargs setfacl -m u:%(web_user)s:rwx """  postsetup_setfacl_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 '%(common_dir)s/data' chown -R %(this_user)s.%(web_group)s '%(common_dir)s/underlay' chmod -R g+w '%(common_dir)s/data' chmod -R g+w '%(common_dir)s/underlay' """  postsetup_chown_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 = (         "show_config",         "setup",         "setup_wiki",         "install_moin",         "install_data",         "install_static_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",         )      source_config_names = (         "moin_distribution", "prefix", "site_packages", "prefix_site_packages",         "htdocs_dir_source"         )      instance_config_names = (         "common_dir", "farm_config", "site_config",         "site_name", "site_identifier",         "front_page_name", "superuser", "theme_default", "htdocs_dir"         )      site_config_names = (         "web_app_dir", "web_site_dir", "web_static_dir",         "url_path", "static_url_path"         )      # 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=None, prefix=None,         site_packages=None, web_app_dir=None, web_static_dir=None, web_site_dir=None,         common_dir=None, farm_config=None, site_config=None, url_path=None,         superuser=None, site_name=None, site_identifier=None, front_page_name=None,         theme_default=None):          """         Initialise a Wiki installation using the following installation         settings:            * moin_distribution - the directory containing a MoinMoin source                                 distribution (can be omitted)           * prefix            - the installation prefix (equivalent to /usr)           * site_packages     - optional: the location of the Python                                 site-packages directory if outside the 'prefix'                                 (overrides the path calculated using 'prefix')           * web_app_dir       - the directory where Web applications and scripts                                 reside (such as /home/www-user/cgi-bin)           * web_static_dir    - optional: the directory where static Web                                 resources reside (such as /home/www-user/htdocs)           * web_site_dir      - optional: the directory where Web site                                 definitions reside (such as                                 /etc/apache2/sites-available)          The following site settings are also applicable:            * common_dir        - the directory where the Wiki configuration,                                 resources and instance will reside (such as                                 /home/www-user/mywiki)           * farm_config       - optional: any Wiki farm configuration file for                                 multiple Wiki deployments (overrides the                                 'common_dir' setting)           * site_config       - optional: a specific configuration file location                                 (overrides the 'common_dir' setting)           * 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")           * site_identifier   - optional: an identifier used to refer to the                                 site, typically derived from 'site_name'           * front_page_name   - the front page name for the site (such as                                 "FrontPage" or a specific name for the site)           * theme_default     - optional: the default theme (such as modern)         """          self.moin_distribution = moin_distribution         self.superuser = superuser         self.site_name = site_name         self.site_identifier = site_identifier or site_name.replace(" ", "").lower()         self.front_page_name = front_page_name         self.farm_config = farm_config         self.site_config = site_config         self.theme_default = theme_default          # NOTE: Support the detection of the Apache sites directory.          self.prefix, self.site_packages, self.web_app_dir, self.web_site_dir, self.web_static_dir, self.common_dir = \             map(self._get_abspath, (prefix, site_packages, web_app_dir, web_site_dir, web_static_dir, common_dir))          if not self.web_app_dir:             raise TypeError, "The 'web_app_dir' setting must be specified."          # Strip any trailing "/" from the URL path.          if not url_path:             raise TypeError, "The 'url_path' setting must be specified."          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.          if not self.common_dir:             raise TypeError, "The 'common_dir' setting must be specified."          # Define the place where the MoinMoin package will actually reside.          if not self.prefix and not self.site_packages:             raise TypeError, "Either the 'prefix' or the 'site_packages' setting must be specified."          self.prefix_site_packages = self.site_packages or \             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, but the Web server is used to serve static         # resources in both cases, even though MoinMoin 1.9 can serve static         # files itself.          # A shared data directory may be in use.          self.htdocs_dir_source = join(self.get_moin_data(), "htdocs")          if self.htdocs_dir_source is None or not exists(self.htdocs_dir_source):              # 1.9: moin/lib/python2.x/site-packages/MoinMoin/web/static/htdocs              if self.moin_version.startswith("1.9"):                 self.htdocs_dir_source = join(self.prefix_site_packages, "MoinMoin", "web", "static", "htdocs")             else:                 raise SetupException, "The static resources could not be found."          # 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.         # This may be placed in a special static directory if desired.          else:             self.htdocs_dir = join(self.web_static_dir or self.common_dir, "htdocs")      def show_config(self):          "Show the configuration."          print         for section in ("source", "instance", "site"):             print section.title()             print "-" * len(section)             print             for setting in getattr(self, "%s_config_names" % section):                 print "%-20s%s" % (setting, getattr(self, setting))             print      def _get_abspath(self, d):         return d and abspath(d) or None      def get_moin_version(self):          "Return the MoinMoin version."          if self.moin_distribution:             this_dir = os.getcwd()             try:                 os.chdir(self.moin_distribution)                 version = self.get_moin_version_from_package_info() or \                     self.get_moin_version_from_import()                 if version:                     return version              finally:                 os.chdir(this_dir)          else:             return self.get_moin_version_from_import()      def get_moin_version_from_package_info(self):          "Inspect the MoinMoin package information, returning the version."          try:             f = open("PKG-INFO")             try:                 for line in f.xreadlines():                     columns = line.split()                     if columns[0] == "Version:":                         return columns[1]             finally:                 f.close()          except IOError:             pass          return None      def get_moin_version_from_import(self):          "Return the MoinMoin version from an import of the package itself."          # 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 exact location of MoinMoin data."          return self.moin_distribution and join(self.moin_distribution, "wiki") or \             self.prefix and join(self.prefix, "share", "moin") or None      def get_wikiconfig_directory(self):          "Return the location of the Wiki configuration."          if self.site_config:             return split(self.site_config)[0]         else:             return self.common_dir      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.common_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.common_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.edit_moin_script()         self._setup_wiki()      def setup_wiki(self):          "Set up a Wiki without installing MoinMoin."          self.ensure_directories()         self._setup_wiki()      def _setup_wiki(self):          "Set up a Wiki without installing MoinMoin."          self.install_data()         self.install_static_data()         self.configure_moin()         self.add_superuser()         self.edit_moin_web_script(self.make_site_files())         self.make_post_install_script()          if self.moin_version.startswith("1.9"):             note("You may need to visit the LanguageSetup page in the Wiki to create the standard set of pages.")      def install_moin(self):          "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 in %s..." % self.prefix)          install_cmd = "install"         options = "--prefix='%s' --record='%s'" % (self.prefix, 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 into an instance."          moin_data = self.get_moin_data()          if not moin_data:             raise SetupException, \                 "Cannot install MoinMoin data without either a 'moin_distribution' or a 'prefix' setting being defined."          # The default wikiconfig assumes data and underlay in the same directory.          status("Installing data and underlay in %s..." % self.common_dir)          for d in ("data", "underlay"):             source = join(moin_data, d)             source_tar = source + os.path.extsep + "tar"              if os.path.exists(source):                 shutil.copytree(source, join(self.common_dir, d))             elif os.path.exists(source_tar):                  note("Copying archive %s instead of directory %s. Running...\n"                     "make pagepacks\n"                     "in the distribution directory should rectify this." % (source_tar, source))                  shutil.copy(source_tar, self.common_dir)                 os.system("tar xf %s -C %s" % (source_tar, self.common_dir))             else:                 status("Could not copy %s into installed Wiki." % d)      def install_static_data(self):          "Install static Web data if appropriate."          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 'prefix' setting being defined."          # NOTE: Single Wiki only so far.          # 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.          url_prefix_static = "%r" % self.static_url_path          # Use a farm configuration file.          if self.farm_config:             wikiconfig_py = self.farm_config          # Or copy the Wiki configuration file from the distribution.          else:             wikiconfig_py = join(self.common_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)              # Edit any created Wiki configuration.              if not self.site_config:                 self._configure_moin(wikiconfig)          finally:             wikiconfig.close()          # Edit any separate site configuration file.          if self.site_config:             status("Editing configuration from %s..." % self.site_config)              wikiconfig = Configuration(self.site_config)              try:                 self._configure_moin(wikiconfig)             finally:                 wikiconfig.close()      def _configure_moin(self, wikiconfig):          """         Configure Moin, accessing the configuration file using 'wikiconfig'.         """          # Specific site configurations also appear to need 'data_dir', even in         # 1.9.          if not self.moin_version.startswith("1.9") or self.site_config:             data_dir = join(self.common_dir, "data")             data_underlay_dir = join(self.common_dir, "underlay")              wikiconfig.set("data_dir", data_dir)             wikiconfig.set("data_underlay_dir", data_underlay_dir)          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.common_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)          # Fix the cause of opaque errors in some Apache environments.          os.system("chmod go-w '%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.common_dir         else:             os.environ["PYTHONPATH"] = self.common_dir          cmd = moin_script + " --config-dir='%s' account create --name='%s' --email='%s' --password='%s'" % (             self.common_dir, self.superuser, email, password)         os.system(cmd)          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_identifier)              s = apache_site % self.__dict__             s += apache_site_extra % 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.\n"                 "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.common_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_extra),             (postinst_scripts[1], postsetup_setfacl, postsetup_setfacl_extra)             ]:              s = start % vars             s += extra % vars              writefile(postinst_script, s)             os.chmod(postinst_script, 0755)          if have_setfacl:             note("Run %s to set file ownership and permissions.\n"                 "If this somehow fails..." % postinst_scripts[1])          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.          If the 'site_config' setting is defined, the specific site configuration         will be changed.         """          if self.site_config:             wikiconfig_py = self.site_config         else:             wikiconfig_py = join(self.common_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'.          If the 'farm_config' setting is defined, the Wiki farm configuration         will be changed.         """          if self.farm_config:             wikiconfig_py = self.farm_config         else:             wikiconfig_py = join(self.common_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.\n"             "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)          options = "install --install-lib=%s" % self.prefix_site_packages          os.system("python setup.py %s" % options)         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", "")          conf_dir = self.get_wikiconfig_directory()          if path:             os.environ["PYTHONPATH"] = path + ":" + self.prefix_site_packages + ":" + conf_dir         else:             os.environ["PYTHONPATH"] = self.prefix_site_packages + ":" + conf_dir          installer = join(self.prefix_site_packages, "MoinMoin", "packages.py")         cmd = "python %s i %s" % (installer, package_filename)         os.system(cmd)          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> ] ( -m <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")          if not exists(config_filename):             print "Configuration", config_filename, "not found."             sys.exit(1)          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, exc:         print "Error:"         print         print exc.args[0]         print         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, exc:         print "Error:"         print         print exc.args[0]         print         print "Method documentation:"         print         print method.__doc__         print         sys.exit(1)  # vim: tabstop=4 expandtab shiftwidth=4