Apache support

hooks/backend.py

 ## These normally depend on python packages being installed
 ## from hooks/install. If we are unable to use external code
 ## due to some  deployment restrictions these deps will already
 ## have been installed or this code will fail.
 from charmhelpers import (
     log,
     open_port,
     service_control,
     RESTART,
     STOP,
 )
 from shelltoolbox import (
     apt_get_install,
     command,
     install_extra_repositories,
     su,
 )
 
 from utils import (
     AGENT,
+    APACHE,
     HAPROXY,
     IMPROV,
     JUJU_DIR,
-    NGINX,
     chain,
     check_packages,
     cmd_log,
     fetch_api,
     fetch_gui,
     get_config,
     legacy_juju,
     merge,
     overrideable,
     save_or_create_certificates,
     setup_gui,
-    setup_nginx,
+    setup_apache,
     start_agent,
     start_gui,
     start_improv,
 )
 
 import os
 import shutil
 
 
 apt_get = command('apt-get')
 
 class InstallMixin(object):
     def install(self, backend):
         config = backend.config
         missing = backend.check_packages(*backend.debs)
         if missing:
             cmd_log(backend.install_extra_repositories(*backend.repositories))
             cmd_log(apt_get_install(*backend.debs))
 
         if backend.different('juju-gui-source'):
             release_tarball = fetch_gui(
                 config['juju-gui-source'], config['command-log-file'])
             setup_gui(release_tarball)
 
 class UpstartMixin(object):
-    upstart_scripts = ('haproxy.conf', 'nginx.conf')
-    debs = ('curl', 'openssl', 'nginx', 'haproxy')
+    upstart_scripts = ('haproxy.conf', )
+    debs = ('curl', 'openssl', 'haproxy', 'apache2')
 
     def install(self, backend):
         """Set up haproxy and nginx upstart configuration files."""
+        setup_apache()
         backend.log('Setting up haproxy and nginx start up scripts.')
         config = backend.config
-        setup_nginx()
         if backend.different('ssl-cert-path', 'ssl-cert-contents', 'ssl-key-contents'):
             save_or_create_certificates(
                 config['ssl-cert-path'], config.get('ssl-cert-contents'),
                 config.get('ssl-key-contents'))
 
         source_dir = os.path.join(os.path.dirname(__file__),  '..', 'config')
         for config_file in backend.upstart_scripts:
             shutil.copy(os.path.join(source_dir, config_file), '/etc/init/')
 
     def start(self, backend):
         with su('root'):
-            backend.service_control(NGINX, RESTART)
+            backend.service_control(APACHE, RESTART)
             backend.service_control(HAPROXY, RESTART)
 
     def stop(self, backend):
         with su('root'):
             backend.service_control(HAPROXY, STOP)
-            backend.service_control(NGINX, STOP)
+            backend.service_control(APACHE, STOP)
 
 
 class GuiMixin(object):
     gui_properties =  set([
         'juju-gui-console-enabled', 'login-help', 'read-only',
         'serve-tests', 'secure'])
 
     repositories = ('ppa:juju-gui/ppa',)
 
     def start(self, config):
@@ skipping 52 matching lines @@
         to use together to implement the backend proper."""
         # Ingest the config and build out the ordered list of
         # backend elements to include
         if config is None:
             config = get_config()
         self.config = config
         self.prev_config = prev_config
         self.overrides = overrides
 
         # We always use upstart.
-        backends = [InstallMixin, UpstartMixin]
+        backends = [InstallMixin, ]
 
         api = "python" if legacy_juju() else "go"
         sandbox = config.get('sandbox', False)
         staging = config.get('staging', False)
 
         if api == 'python':
             if staging:
                 backends.append(ImprovBackend)
             elif sandbox:
                 backends.append(SandboxBackend)
             else:
                 backends.append(PythonBackend)
         else:
             if staging:
                 raise ValueError(
                     "Unable to use staging with {} backend".format(api))
             if sandbox:
                 raise ValueError(
                     "Unable to use sandbox with {} backend".format(api))
             backends.append(GoBackend)
 
         # All backends can manage the gui.
         backends.append(GuiMixin)
+        backends.append(UpstartMixin)

[teknico, 2013/04/23 16:41:50]

So UpstartMixin needs to be last? Why?

[benjamin.saller, 2013/04/23 16:55:41]

The order things start in. The last composed backend should (re)start the
services with the current config. Because start() is used in both hooks/start
and hooks/config-changed (where we rewrite config files) this must come last.

In the future utils like start_gui should be split into the various mixins but I
can't force another round of testing under this timeframe.

 
         # record our choice mapping classes to instances
         for i, b in enumerate(backends):
             if callable(b):
                 backends[i] = b()
         self.backends = backends
 
     def __getitem__(self, key):
         try:
             return self.config[key]
@@ skipping 21 matching lines @@
     def log(self, msg, *args):
         log(msg, *args)
 
     @overrideable
     def install_extra_repositories(self, *packages):
         if self.config.get('allow-additional-deb-repositories', True):
             install_extra_repositories(*packages)
         else:
             apt_get('update')
 
-
     def different(self, *keys):
         """Return a boolean indicating if the current config
         value differs from the config value passed in prev_config
         with respect to any of the passed in string keys.
         """
         if self.prev_config is None:
             return True
 
         for key in keys:
             current = self.config.get(key)
@@ skipping 12 matching lines @@
 
     ## Merged Properties
     dependencies = merge('dependencies')
     build_dependencies = merge('build_dependencies')
     staging_dependencies = merge('staging_dependencies')
 
     repositories = merge('repositories')
     debs = merge('debs')
     upstart_scripts = merge('upstart_scripts')