#!/usr/bin/env python  """ A setup and configuration script for MoinMoin.  Copyright (C) 2010, 2011, 2012 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, islink, join, normpath, split from os import chdir, chmod, listdir, mkdir, makedirs, remove, rename, rmdir from getpass import getpass from glob import glob from zipfile import ZipFile import os import sys import shutil import re import tempfile  __version__ = "0.4"  # 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_resources_path)s "%(htdocs_dir)s/" """  # Limited hosting .htaccess definitions require the following settings to be # configured in the main Apache configuration files for the directory where # .htaccess is to be deployed: # # AllowOverride FileInfo Indexes # # The following settings are required for the directory where the moin.cgi # script is to be deployed: # # Options ExecCGI FollowSymLinks SymLinksIfOwnerMatch # AddHandler cgi-script .cgi # # If a DirectoryIndex directive is also desired, the Indexes option must be set. # Such a directive is not desirable where the static and dynamic resources are # in different places, however.  apache_htaccess_combined_mod_rewrite = """\ DirectoryIndex %(url_path_tr)s/moin.cgi/ RewriteEngine On RewriteBase %(final_url_path)s RewriteCond %%{REQUEST_FILENAME} !-f RewriteCond %%{REQUEST_FILENAME} !-d RewriteRule ^(.*) %(url_path_tr)s/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 if [ -e "%(common_dir)s/wikiconfig.py" ]; then     setfacl -m u:%(web_user)s:r '%(common_dir)s/wikiconfig.py' fi """  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_setfacl_logs = """ if [ -e "%(common_dir)s/data/*-log" ]; then     setfacl -m u:%(web_user)s:rw %(common_dir)s/data/*-log fi """  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' if [ -e "%(common_dir)s/wikiconfig.py" ]; then     chown %(this_user)s.%(web_group)s '%(common_dir)s/wikiconfig.py'     chmod g+r '%(common_dir)s/wikiconfig.py' fi """  postsetup_chown_extra = """ chown -R %(this_user)s.%(web_group)s '%(htdocs_dir)s' """  postsetup_chown_logs = """ if [ -e "%(common_dir)s/data/*-log" ]; then     chown %(this_user)s.%(web_group)s %(common_dir)s/data/*-log fi """  # 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",          # Post-installation activities.          "reconfigure_moin",         "set_auth_method",         "migrate_instance",         "install_theme",         "install_extension_package",         "install_plugins",         "install_actions",         "install_macros",         "install_parsers",         "install_event_handlers",         "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: Potentially detect Web server credentials.      web_user_default = "www-data"     web_group_default = "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,         web_user=None, web_group=None,         common_dir=None, farm_config=None, site_config=None,         url_path=None, static_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)           * web_user          - optional: the user operating the Web server           * web_group         - optional: the group of the Web server user          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)           * static_url_path   - optional: the URL path at which static resources                                 will be made available (such as / or /mywiki)           * superuser         - the name of the site's superuser (such as                                 "AdminUser", can be omitted)           * 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          self.web_user = web_user or self.web_user_default         self.web_group = web_group or self.web_group_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."          self.url_path = self._tidy_url_path(url_path)         self.static_url_path = static_url_path and self._tidy_url_path(static_url_path)          self.url_path_tr = self._truncate_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         #         # This allows multiple Wiki instances to have their own static resources         # in the same hosting area.         #         # Where a separate static URL path has been given, the resources are         # located under that path:         #         # /         -> /moin_static187         # /hgwiki   -> /hgwiki/moin_static187          # The final URL path is the principal location of the Wiki.          self.final_url_path = self.static_url_path or self.url_path          # The static URL resources path is the specific location of static         # resources.          self.static_url_resources_path = \             self.final_url_path + \             (self.static_url_path                 and (self.static_url_path != "/"                     and "/"                     or "")                 or (self.final_url_path != "/"                     and "-"                     or "")) + \             self.get_static_identifier()          self.static_dir_name = self.static_url_resources_path.split("/")[-1]          # In limited hosting, the static resources directory is related to         # the URL path, either a specified static URL path or the general path.          if self.limited_hosting():             self.htdocs_dir = join(self.web_static_dir or self.web_app_dir, self.static_dir_name)          # 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         if self.limited_hosting():             print "Limited hosting configuration detected."             print "Published resources will be configured using .htaccess."         else:             print "Privileged hosting configuration detected..."             print "Published resources will be configured using site definition files."         print         for section in ("source", "instance", "site"):             print section.title()             print "-" * len(section)             print             for setting in getattr(self, "%s_config_names" % section):                 print "%-24s%s" % (setting, getattr(self, setting))             print          print "Configuration locations"         print "-----------------------"         print         print "%-24s%s" % ("site-level", self.get_site_config())         print "%-24s%s" % ("global", self.get_global_config())         print         print "Theme directories"         print "-----------------"         print          try:             for theme in self.get_theme_directories():                 print "%-24s%s" % theme         except OSError, exc:             print "Not shown:", str(exc)      def _get_abspath(self, d):         return d and abspath(d) or None      def _tidy_url_path(self, url_path):         if url_path != "/" and url_path.endswith("/"):             return url_path[:-1]         else:             return url_path      def _truncate_url_path(self, url_path):         if url_path.endswith("/"):             return url_path[:-1]         else:             return url_path      def _set_pythonpath(self):         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          return path      def _reset_pythonpath(self, path):         if path:             os.environ["PYTHONPATH"] = path         else:             del os.environ["PYTHONPATH"]      def get_moin_version(self):          "Return the MoinMoin version."          this_dir = os.getcwd()          for dir in [self.moin_distribution, self.prefix_site_packages]:             if dir:                 try:                     chdir(dir)                     version = self.get_moin_version_from_package_info() or \                         self.get_moin_version_from_import()                     if version:                         return version                  finally:                     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_moin_script(self):          "Return the location of the general-purpose moin script."          return join(self.prefix, "bin", "moin")      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_site_config(self):          "Return the file providing the site-level configuration."          if self.site_config:             return self.site_config         else:             return join(self.common_dir, "wikiconfig.py")      def get_global_config(self):          "Return the file providing the global MoinMoin configuration."          if self.farm_config:             return self.farm_config         else:             return join(self.common_dir, "wikiconfig.py")      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):                 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 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()         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("%s setup.py --quiet %s %s --force" % (sys.executable, install_cmd, options))          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 + extsep + "tar"              if exists(source):                 shutil.copytree(source, join(self.common_dir, d))             elif 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):             mkdir(self.htdocs_dir)          for item in 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, reset=0):          """         Edit the Wiki configuration file. If the optional 'reset' parameter is         specified as a true value, a default configuration will be copied from         the distribution if appropriate.         """          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: 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_resources_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")              if not exists(wikiconfig_py) or reset:                 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)             if self.superuser:                 wikiconfig.set("superuser", [self.superuser])                 wikiconfig.set("acl_rights_before", u"%s:read,write,delete,revert,admin" % self.superuser)             else:                 note("Superuser not defined. The ACL rules should be fixed in the configuration.")              # 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 = self.get_moin_script()         status("Editing moin script at %s..." % moin_script)          s = readfile(moin_script)         s = s.replace("#!/usr/bin/env python", "#!%s" % sys.executable)         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 = s.replace("#!/usr/bin/env python", "#!%s" % sys.executable)         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:                 url_path = self.final_url_path                  if self.moin_version.startswith("1.9"):                     s = moin_cgi_fix_script_name.sub(r"\1\2 %r" % url_path, s)                 else:                     s = moin_cgi_properties.sub(r"\1\2 %r" % {"script_name" : 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."          if not self.superuser:             return          print "Creating superuser", self.superuser, "using..."         email = raw_input("E-mail address: ")         password = getpass("Password: ")          path = self._set_pythonpath()          cmd = "%s --config-dir='%s' account create --name='%s' --email='%s' --password='%s'" % (             self.get_moin_script(), self.common_dir, self.superuser, email, password)         os.system(cmd)          self._reset_pythonpath(path)      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_static_dir or 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          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, logs in [             (postinst_scripts[0], postsetup_chown_chmod, postsetup_chown_extra, postsetup_chown_logs),             (postinst_scripts[1], postsetup_setfacl, postsetup_setfacl_extra, postsetup_setfacl_logs)             ]:              s = start % vars             s += extra % vars             s += logs % vars              writefile(postinst_script, s)             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.         """          wikiconfig_py = self.get_site_config()          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'.          Currently recognised authentication methods are:            * openid             (uses OpenIDAuth to access OpenID providers)           * moin, default      (use MoinAuth to provide a login form)           * given, remote-user (use HTTPAuth to obtain Web server credentials)          If the 'farm_config' setting is defined, the Wiki farm configuration         will be changed.         """          wikiconfig_py = self.get_global_config()          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 migrate_instance(self, test=0, change_site=0):          """         Migrate the Wiki to the currently supported layout. If 'test' is         specified and set to a non-empty or true value, only print whether the         migration can be performed.          If 'change_site' is specified and set to a non-empty or true value, the         site definitions will be updated; this will overwrite any changes made         to the site definitions after they were last produced by moinsetup, and         care must be taken to ensure that things like access controls are         re-added to the definitions after this action is performed.         """          conf_dir = join(self.common_dir, "conf")         if exists(conf_dir):             for filename in listdir(conf_dir):                 pathname = join(conf_dir, filename)                 target = join(self.common_dir, filename)                 if not exists(target):                     print "Move", filename, "from conf directory."                     if not test:                         rename(pathname, target)         else:             print "No conf directory."          wikidata = join(self.common_dir, "wikidata")         if exists(wikidata):             htdocs = join(wikidata, "share", "moin", "htdocs")             if exists(htdocs):                 target = join(self.common_dir, "htdocs")                 if not exists(target):                     print "Move htdocs from wikidata directory."                     if not test:                         rename(htdocs, target)         else:             print "No wikidata directory."          # Remove links and directories.          for name in ("conf", "wikidata"):             d = join(self.common_dir, name)             if islink(d):                 print "Remove %s symbolic link." % name                 if not test:                     remove(d)          if isdir(conf_dir):             print "Remove conf directory."             if not test:                 rmdir(conf_dir)          # Add any missing htdocs directory.          if not exists(self.htdocs_dir):             print "Copy htdocs into the instance."             if not test:                 self.install_static_data()          # Now attempt to reconfigure the Wiki.          print "Reconfigure the Wiki, the Web script%s." % (change_site and " and the site files" or "")         if not test:             self.configure_moin()             self.edit_moin_web_script()             if change_site:                 self.make_site_files()      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):             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()         chdir(extension_dir)          try:             options = "install --install-lib=%s" % self.prefix_site_packages             os.system("%s setup.py %s" % (sys.executable, options))         finally:             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))          # If a setup file is detected, abandon the installation.          if exists(join(plugins_dir, "setup%spy" % extsep)):             print "Plugins not installed: setup%spy was detected." % extsep             return          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 parsers provided in the given 'parsers_dir'."          self.install_plugins(parsers_dir, "parser")      def install_event_handlers(self, events_dir):          "Install Wiki event handlers provided in the given 'events_dir'."          self.install_plugins(events_dir, "events")      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"]             self._add_page_package_files(page_directory, "", package, script)             package.writestr("MOIN_PACKAGE", "\n".join(script) + "\n")          finally:             package.close()      def _add_page_package_files(self, page_directory, prefix, package, script):          """         Add files in the given 'page_directory' as pages with the given 'prefix'         to the given 'package', recording them in the given 'script'.         """          filenames = listdir(page_directory)         filenames.sort()          for filename in filenames:             pathname = join(page_directory, filename)              # Add files as pages having the filename as page name.              if os.path.isfile(pathname):                 pagename = prefix + filename                 zipname = pagename.replace("/", "__")                 package.write(pathname, zipname)                 script.append("AddRevision|%s|%s" % (zipname, pagename))              elif os.path.isdir(pathname):                  # Add directories ending with "-attachments" as collections of                 # attachments for a particular page.                  if filename.endswith("-attachments"):                     pagename = prefix + filename[:-len("-attachments")]                     zipname = pagename.replace("/", "__")                      # Add each file as an attachment.                      for attachment in listdir(pathname):                         azipname = "%s_%s" % (zipname, attachment)                         package.write(join(pathname, attachment), azipname)                         script.append("AddAttachment|%s|%s|%s||" % (                             azipname, attachment, pagename))                  # Descend into other directories.                  else:                     pagename = prefix + filename                     self._add_page_package_files(pathname, "%s/" % pagename, package, script)      def install_page_package(self, package_filename):          """         Install a package from the file with the given 'package_filename'.         """          path = self._set_pythonpath()         installer = join(self.prefix_site_packages, "MoinMoin", "packages.py")         cmd = "%s %s i %s" % (sys.executable, installer, package_filename)         os.system(cmd)         self._reset_pythonpath(path)  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