#!/usr/bin/env python  from os.path import abspath, exists, extsep, isdir, join, normpath, split from getpass import getpass from glob import glob import os import sys import shutil import re  # Regular expressions for editing MoinMoin scripts and configuration files.  def compile_definition(name):     return re.compile(r"^(\s*)#*\s*(%s =).*$" % name, re.MULTILINE)  moin_cgi_prefix          = re.compile("^#sys\.path\.insert\(0, 'PREFIX.*$", re.MULTILINE) moin_cgi_wikiconfig      = re.compile("^#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("^#(os.environ\['FCGI_FORCE_CGI'\].*)$", re.MULTILINE)  css_import_stylesheet    = re.compile("(\s*@import\s+[\"'])(.*?)([\"']\s*;)")  # Templates for Apache site definitions.  apache_site = """ ScriptAlias %(url_path)s "%(web_app_dir)s/moin.cgi" """  apache_site_extra_moin18 = """ Alias %(static_url_path)s "%(htdocs_dir)s/" """  # Limited hosting .htaccess definitions require the following settings to be # configured in the main Apache configuration files: # # Options ExecCGI FollowSymLinks Indexes SymLinksIfOwnerMatch # AllowOverride FileInfo Limit # AddHandler cgi-script .cgi  apache_htaccess_combined_mod_rewrite = """ DirectoryIndex moin.cgi RewriteEngine On RewriteBase %(url_path)s RewriteCond %%{REQUEST_FILENAME} !-f RewriteCond %%{REQUEST_FILENAME} !-d RewriteRule ^(.*) moin.cgi/$1 [PT,L,QSA] """  # 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 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 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 = "\n    %s = %s\n"         else:             insertion = "\n    %s = %r\n"          self.content += insertion % (name, value)      def close(self):          "Close the file, writing the content."          writefile(self.filename, self.content)  class Installation:      "A class for installing and initialising MoinMoin."      method_names = (         "setup",         "setup_wiki",         "install_moin",         "install_data",         "configure_moin",         "edit_moin_script",         "edit_moin_web_script",         "add_superuser",         "make_site_files",         "make_post_install_script",         "reconfigure_moin",         "install_theme",         "install_extension_package",         "install_plugins",         "install_actions",         "install_macros",         "install_theme_resources",         "edit_theme_stylesheet"         )      # 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, prefix, web_app_dir, web_site_dir,         common_dir, url_path, superuser, site_name, front_page_name,         theme_default=None):          """         Initialise a Wiki installation using the following:            * moin_distribution - the directory containing a MoinMoin source                                 distribution           * prefix            - the installation prefix (equivalent to /usr)           * web_app_dir       - the directory where Web applications and scripts                                 reside (such as /home/www-user/cgi-bin)           * web_site_dir      - the directory where Web site definitions reside                                 (such as /etc/apache2/sites-available)           * common_dir        - the directory where the Wiki configuration,                                 resources and instance will reside (such as                                 /home/www-user/mywiki)           * url_path          - the URL path at which the Wiki will be made                                 available (such as / or /mywiki)           * superuser         - the name of the site's superuser (such as                                 "AdminUser")           * site_name         - the name of the site (such as "My Wiki")           * front_page_name   - the front page name for the site (such as                                 "FrontPage" or a specific name for the site)           * theme_default     - optional: the default theme (such as modern)         """          self.moin_distribution = moin_distribution         self.superuser = superuser         self.site_name = site_name         self.front_page_name = front_page_name         self.theme_default = theme_default          # NOTE: Support the detection of the Apache sites directory.          self.prefix, self.web_app_dir, self.web_site_dir, self.common_dir = \             map(abspath, (prefix, web_app_dir, web_site_dir, common_dir))          # Strip any trailing "/" from the URL path.          if url_path != "/" and url_path.endswith("/"):             self.url_path = url_path[:-1]         else:             self.url_path = url_path          # Define and create specific directories.          self.conf_dir = join(self.common_dir, "conf")         self.instance_dir = join(self.common_dir, "wikidata")          # Define useful directories.          self.prefix_site_packages = join(self.prefix, "lib", "python%s.%s" % sys.version_info[:2], "site-packages")          # Find the version.          self.moin_version = self.get_moin_version()          # The static resources reside in different locations depending on the         # version of MoinMoin. Moreover, these resources may end up in a         # published directory for 1.8 installations where the Web server cannot         # be instructed to fetch the content from outside certain designated         # locations.          # 1.9: moin/lib/python2.x/site-packages/MoinMoin/web/static/htdocs          if self.moin_version.startswith("1.9"):             self.htdocs_dir = self.htdocs_dir_source = join(self.prefix_site_packages, "MoinMoin", "web", "static", "htdocs")          # 1.8: moin/share/moin/htdocs (optionally copied to a Web directory)          else:             self.htdocs_dir_source = join(self.instance_dir, "share", "moin", "htdocs")              if self.limited_hosting():                 self.htdocs_dir = join(self.web_app_dir, self.get_static_identifier())             else:                 self.htdocs_dir = self.htdocs_dir_source      def get_moin_version(self):          "Inspect the MoinMoin package information, returning the version."          this_dir = os.getcwd()         os.chdir(self.moin_distribution)          try:             try:                 f = open("PKG-INFO")                 try:                     for line in f.xreadlines():                         columns = line.split()                         if columns[0] == "Version:":                             return columns[1]                      return None                  finally:                     f.close()              except IOError:                 f = os.popen("%s -c 'from MoinMoin.version import release; print release'" % sys.executable)                 try:                     return f.read().strip()                 finally:                     f.close()         finally:             os.chdir(this_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.conf_dir, "data")         return join(data_dir, "plugin", plugin_type)      def limited_hosting(self):          "Return whether limited Web hosting is being used."          return self.web_site_dir == self.web_app_dir      def ensure_directories(self):          "Make sure that all the directories are available."          for d in (self.conf_dir, self.instance_dir, self.web_app_dir, self.web_site_dir):             if not exists(d):                 os.makedirs(d)      def get_theme_directories(self, theme_name=None):          """         Return tuples of the form (theme name, theme directory) for all themes,         or for a single theme if the optional 'theme_name' is specified.         """          filenames = theme_name and [theme_name] or os.listdir(self.htdocs_dir)         directories = []          for filename in filenames:             theme_dir = join(self.htdocs_dir, filename)              if not exists(theme_dir) or not isdir(theme_dir):                 continue              directories.append((filename, theme_dir))          return directories      # Main methods.      def setup(self):          "Set up the installation."          self.ensure_directories()         self.install_moin()         self._setup_wiki()      def setup_wiki(self):          "Set up a Wiki without installing MoinMoin."          self.ensure_directories()         self.install_moin(data_only=1)         self._setup_wiki()      def _setup_wiki(self):          "Set up a Wiki without installing MoinMoin."          self.install_data()         self.configure_moin()         self.edit_moin_script()         self.edit_moin_web_script()         self.add_superuser()         self.make_site_files()         self.make_post_install_script()      def install_moin(self, data_only=0):          "Enter the distribution directory and run the setup script."          # NOTE: Possibly check for an existing installation and skip repeated         # NOTE: installation attempts.          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)          if data_only:             install_cmd = "install_data"             options = "--install-dir='%s'" % self.instance_dir         else:             install_cmd = "install"             options = "--prefix='%s' --install-data='%s' --record='%s'" % (self.prefix, self.instance_dir, log_filename)          os.system("python setup.py --quiet %s %s --force" % (install_cmd, options))          os.chdir(this_dir)      def install_data(self):          "Install Wiki data."          # The default wikiconfig assumes data and underlay in the same directory.          status("Installing data and underlay in %s..." % self.conf_dir)          for d in ("data", "underlay"):             source = join(self.moin_distribution, "wiki", d)             source_tar = source + os.path.extsep + "tar"             d_tar = source + os.path.extsep + "tar"              if os.path.exists(source):                 shutil.copytree(source, join(self.conf_dir, d))             elif os.path.exists(source_tar):                 shutil.copy(source_tar, self.conf_dir)                 os.system("tar xf %s -C %s" % (d_tar, self.conf_dir))             else:                 status("Could not copy %s into installed Wiki." % d)          # Copy static Web data if appropriate.          if not self.moin_version.startswith("1.9") and self.limited_hosting():              if not exists(self.htdocs_dir):                 os.mkdir(self.htdocs_dir)              for item in os.listdir(self.htdocs_dir_source):                 path = join(self.htdocs_dir_source, item)                 if isdir(path):                     shutil.copytree(path, join(self.htdocs_dir, item))                 else:                     shutil.copy(path, join(self.htdocs_dir, item))      def configure_moin(self):          "Edit the Wiki configuration file."          # NOTE: Single Wiki only so far.          # Static URLs seem to be different in MoinMoin 1.9.x.         # For earlier versions, reserve URL space alongside the Wiki.         # NOTE: MoinMoin usually uses an apparently common URL space associated         # NOTE: with the version, but more specific locations are probably         # NOTE: acceptable if less efficient.          if self.moin_version.startswith("1.9"):             self.static_url_path = self.url_path             url_prefix_static = "%r + url_prefix_static" % self.static_url_path         else:             # 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()             url_prefix_static = "%r" % self.static_url_path          # Copy the Wiki configuration file from the distribution.          wikiconfig_py = join(self.conf_dir, "wikiconfig.py")         shutil.copyfile(join(self.moin_distribution, "wiki", "config", "wikiconfig.py"), wikiconfig_py)          status("Editing configuration from %s..." % wikiconfig_py)          # Edit the Wiki configuration file.          wikiconfig = Configuration(wikiconfig_py)          try:             wikiconfig.set("url_prefix_static", url_prefix_static, raw=1)             wikiconfig.set("superuser", [self.superuser])             wikiconfig.set("acl_rights_before", u"%s:read,write,delete,revert,admin" % self.superuser)              if not self.moin_version.startswith("1.9"):                 data_dir = join(self.conf_dir, "data")                 data_underlay_dir = join(self.conf_dir, "underlay")                  wikiconfig.set("data_dir", data_dir)                 wikiconfig.set("data_underlay_dir", data_underlay_dir)              self._configure_moin(wikiconfig)          finally:             wikiconfig.close()      def _configure_moin(self, wikiconfig):          """         Configure Moin, accessing the configuration file using 'wikiconfig'.         """          wikiconfig.set("site_name", self.site_name)         wikiconfig.set("page_front_page", self.front_page_name, count=1)          if self.theme_default is not None:             wikiconfig.set("theme_default", self.theme_default)      def edit_moin_script(self):          "Edit the moin script."          moin_script = join(self.prefix, "bin", "moin")          status("Editing moin script at %s..." % moin_script)          s = readfile(moin_script)         s = s.replace("#import sys", "import sys\nsys.path.insert(0, %r)" % self.prefix_site_packages)          writefile(moin_script, s)      def edit_moin_web_script(self):          "Edit and install CGI script."          # NOTE: CGI only so far.         # NOTE: Permissions should be checked.          if self.moin_version.startswith("1.9"):             moin_cgi = join(self.instance_dir, "share", "moin", "server", "moin.fcgi")         else:             moin_cgi = join(self.instance_dir, "share", "moin", "server", "moin.cgi")          moin_cgi_installed = join(self.web_app_dir, "moin.cgi")          status("Editing moin.cgi script from %s..." % moin_cgi)          s = readfile(moin_cgi)         s = moin_cgi_prefix.sub("sys.path.insert(0, %r)" % self.prefix_site_packages, s)         s = moin_cgi_wikiconfig.sub("sys.path.insert(0, %r)" % self.conf_dir, s)          # Handle differences in script names when using limited hosting with         # URL rewriting.          if self.limited_hosting():             if self.moin_version.startswith("1.9"):                 s = moin_cgi_fix_script_name.sub(r"\1\2 %r" % self.url_path, s)             else:                 s = moin_cgi_properties.sub(r"\1\2 %r" % {"script_name" : self.url_path}, s)          # NOTE: Use CGI for now.          if self.moin_version.startswith("1.9"):             s = moin_cgi_force_cgi.sub(r"\1", s)          writefile(moin_cgi_installed, s)         os.system("chmod a+rx '%s'" % moin_cgi_installed)      def add_superuser(self):          "Add the superuser account."          moin_script = join(self.prefix, "bin", "moin")          print "Creating superuser", self.superuser, "using..."         email = raw_input("E-mail address: ")         password = getpass("Password: ")          path = os.environ.get("PYTHONPATH", "")          if path:             os.environ["PYTHONPATH"] = path + ":" + self.conf_dir         else:             os.environ["PYTHONPATH"] = self.conf_dir          os.system(moin_script + " account create --name='%s' --email='%s' --password='%s'" % (self.superuser, email, password))          if path:             os.environ["PYTHONPATH"] = path         else:             del os.environ["PYTHONPATH"]      def make_site_files(self):          "Make the Apache site files."          # NOTE: Using local namespace for substitution.          # Where the site definitions and applications directories are different,         # use a normal site definition.          if not self.limited_hosting():              site_def = join(self.web_site_dir, self.site_name)              s = apache_site % self.__dict__              if not self.moin_version.startswith("1.9"):                 s += apache_site_extra_moin18 % self.__dict__          # Otherwise, use an .htaccess file.          else:             site_def = join(self.web_site_dir, ".htaccess")              s = apache_htaccess_combined_mod_rewrite % self.__dict__          status("Writing Apache site definitions to %s..." % site_def)          writefile(site_def, s)      def make_post_install_script(self):          "Write a post-install script with additional actions."          this_user = os.environ["USER"]         postinst_script = "moinsetup-post.sh"          s = "#!/bin/sh\n"          for d in ("data", "underlay"):             s += "chown -R %s.%s '%s'\n" % (this_user, self.web_group, join(self.conf_dir, d))             s += "chmod -R g+w '%s'\n" % join(self.conf_dir, d)          if not self.moin_version.startswith("1.9"):             s += "chown -R %s.%s '%s'\n" % (this_user, self.web_group, self.htdocs_dir)          writefile(postinst_script, s)         os.chmod(postinst_script, 0755)         note("Run %s as root to set file ownership and permissions." % postinst_script)      # Accessory methods.      def reconfigure_moin(self, name=None, value=None, raw=0):          "Edit the installed Wiki configuration file."          wikiconfig_py = join(self.conf_dir, "wikiconfig.py")          status("Editing configuration from %s..." % wikiconfig_py)          wikiconfig = Configuration(wikiconfig_py)          try:             # Perform default configuration.              if name is None and value is None:                 self._configure_moin(wikiconfig)             else:                 wikiconfig.set(name, value, raw=raw)          finally:             wikiconfig.close()      def install_theme(self, theme_dir):          "Install Wiki theme provided in the given 'theme_dir'."          theme_dir = normpath(theme_dir)         theme_name = split(theme_dir)[-1]         theme_module = join(theme_dir, theme_name + extsep + "py")          plugin_theme_dir = self.get_plugin_directory("theme")          # Copy the theme module.          status("Copying theme module to %s..." % plugin_theme_dir)          shutil.copy(theme_module, plugin_theme_dir)          # Copy the resources.          resources_dir = join(self.htdocs_dir, theme_name)          if not exists(resources_dir):             os.mkdir(resources_dir)          status("Copying theme resources to %s..." % resources_dir)          for d in ("css", "img"):             target_dir = join(resources_dir, d)             if exists(target_dir):                 status("Replacing %s..." % target_dir)                 shutil.rmtree(target_dir)             shutil.copytree(join(theme_dir, d), target_dir)          # Copy additional resources from other themes.          resources_source_dir = join(self.htdocs_dir, self.theme_master)         target_dir = join(resources_dir, "css")          status("Copying resources from %s..." % resources_source_dir)          for css_file in self.extra_theme_css_files:             css_file_path = join(resources_source_dir, "css", css_file)             if exists(css_file_path):                 shutil.copy(css_file_path, target_dir)          note("Don't forget to add theme resources for extensions for this theme.")         note("Don't forget to edit theme stylesheets for any extensions.")      def install_extension_package(self, extension_dir):          "Install any libraries from 'extension_dir' using a setup script."          this_dir = os.getcwd()         os.chdir(extension_dir)         os.system("python setup.py install --prefix=%s" % self.prefix)         os.chdir(this_dir)      def install_plugins(self, plugins_dir, plugin_type):          """         Install Wiki actions provided in the given 'plugins_dir' of the         specified 'plugin_type'.         """          plugin_target_dir = self.get_plugin_directory(plugin_type)          # Copy the modules.          status("Copying %s modules to %s..." % (plugin_type, plugin_target_dir))          for module in glob(join(plugins_dir, "*%spy" % extsep)):             shutil.copy(module, plugin_target_dir)      def install_actions(self, actions_dir):          "Install Wiki actions provided in the given 'actions_dir'."          self.install_plugins(actions_dir, "action")      def install_macros(self, macros_dir):          "Install Wiki macros provided in the given 'macros_dir'."          self.install_plugins(macros_dir, "macro")      def install_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 show_methods():     print "Methods:"     print     for method_name in Installation.method_names:         doc = getattr(Installation, method_name).__doc__.strip()         print "%-30s%-s" % (method_name, format(doc, 30))     print  # Command line option syntax.  syntax_description = "[ -f <config-filename> ] --method=METHOD [ <method-argument> ... ]"  # Main program.  if __name__ == "__main__":     from ConfigParser import ConfigParser     import sys, cmdsyntax      # Check the command syntax.      syntax = cmdsyntax.Syntax(syntax_description)     try:         matches = syntax.get_args(sys.argv[1:])         args = matches[0]     except IndexError:         print "Syntax:"         print sys.argv[0], syntax_description         print         show_methods()         sys.exit(1)      # Obtain configuration details.      try:         config_filename = args.get("config-filename", "moinsetup.cfg")         config = ConfigParser()         config.read(config_filename)          # Obtain as many arguments as needed from the configuration.          config_arguments = dict(config.items("installation") + config.items("site"))         method_arguments = args.get("method-argument", [])          # Attempt to initialise the configuration.          installation = Installation(**config_arguments)      except TypeError:         print "Configuration settings:"         print         print Installation.__init__.__doc__         print         sys.exit(1)      # Obtain the method.      try:         method = getattr(installation, args["method"])     except AttributeError:         show_methods()         sys.exit(1)      try:         method(*method_arguments)     except TypeError:         print "Method documentation:"         print         print method.__doc__         print         raise  # vim: tabstop=4 expandtab shiftwidth=4