#!/usr/bin/env python  from os.path import abspath, exists, extsep, join, normpath, split from getpass import getpass 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 =).*$" % 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)  # 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/" """  # 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  def note(message):     print message  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."      # 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.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()          # 1.8: moin/share/moin/htdocs         # 1.9: moin/lib/python2.x/site-packages/MoinMoin/web/static/htdocs          if self.moin_version.startswith("1.9"):             self.htdocs_dir = join(self.prefix_site_packages, "MoinMoin", "web", "static", "htdocs")         else:             self.htdocs_dir = join(self.instance_dir, "share", "moin", "htdocs")      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()                 finally:                     f.close()         finally:             os.chdir(this_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)      # 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)      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:             self.static_url_path = self.url_path + "-static"             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.          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)          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.          site_def = join(self.web_site_dir, self.site_name)         site_def_private = join(self.web_site_dir, "%s-private" % self.site_name)          status("Writing Apache site definitions to %s and %s..." % (site_def, site_def_private))          s = apache_site % self.__dict__          if not self.moin_version.startswith("1.9"):             s += apache_site_extra_moin18 % self.__dict__          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")          data_dir = join(self.conf_dir, "data")         plugin_theme_dir = join(data_dir, "plugin", "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)          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)  # Command line option syntax.  syntax_description = "<argument> ... [ --method=METHOD [ <method-argument> ... ] ]"  # Main program.  if __name__ == "__main__":     import sys, cmdsyntax      # Check the command syntax.      syntax = cmdsyntax.Syntax(syntax_description)     try:         matches = syntax.get_args(sys.argv[1:])         args = matches[0]          # Obtain as many arguments as needed for the configuration.          arguments = args["argument"]         method_arguments = args.get("method-argument", [])          # Attempt to initialise the configuration.          installation = Installation(*arguments)      except (IndexError, TypeError):         print "Syntax:"         print sys.argv[0], syntax_description         print         print "Arguments:"         print Installation.__init__.__doc__         sys.exit(1)      # Obtain and perform the method.      if args.has_key("method"):         method = getattr(installation, args["method"])     else:         method = installation.setup      method(*method_arguments)  # vim: tabstop=4 expandtab shiftwidth=4