##// END OF EJS Templates
wix: functionality to automate building WiX installers...
wix: functionality to automate building WiX installers Like we did for Inno Setup, we want to make it easier to produce WiX installers. This commit does that. We introduce a new hgpackaging.wix module for performing all the high-level tasks required to produce WiX installers. This required miscellaneous enhancements to existing code in hgpackaging, including support for signing binaries. A new build.py script for calling into the module APIs has been created. It behaves very similarly to the Inno Setup build.py script. Unlike Inno Setup, we didn't have code in the repo previously to generate WiX installers. It appears that all existing automation for building WiX installers lives in the https://bitbucket.org/tortoisehg/thg-winbuild repository - most notably in its setup.py file. My strategy for inventing the code in this commit was to step through the code in that repo's setup.py and observe what it was doing. Despite the length of setup.py in that repository, the actual amount of steps required to produce a WiX installer is actually quite low. It consists of a basic py2exe build plus invocations of candle.exe and light.exe to produce the MSI. One rabbit hole that gave me fits was locating the Visual Studio 9 C Runtime merge modules. These merge modules are only present on your system if you have a full Visual Studio 2008 installation. Fortunately, I have a copy of Visual Studio 2008 and was able to install all the required updates. I then uploaded these merge modules to a personal repository on GitHub. That is where the added code references them from. We probably don't need to ship the merge modules. But that is for another day. The installs from the MSIs produced with the new automation differ from the last official MSI in the following ways: * Our HTML manual pages have UNIX line endings instead of Windows. * We ship modules in the mercurial.pure package. It appears the upstream packaging code is not including this package due to omission (they supply an explicit list of packages that has drifted out of sync with our setup.py). * We do not ship various distutils.* modules. This is because virtualenvs have a custom distutils/__init__.py that automagically imports distutils from its original location and py2exe gets confused by this. We don't use distutils in core Mercurial and don't provide a usable python.exe, so this omission should be acceptable. * The version of the enum package is different and we ship an enum.pyc instead of an enum/__init__.py. * The version of the docutils package is different and we ship a different set of files. * The version of Sphinx is drastically newer and we ship a number of files the old version did not. (I'm not sure why we ship Sphinx - I think it is a side-effect of the way the THG code was installing dependencies.) * We ship the idna package (dependent of requests which is a dependency of newer versions of Sphinx). * The version of imagesize is different and we ship an imagesize.pyc instead of an imagesize/__init__.pyc. * The version of the jinja2 package is different and the sets of files differs. * We ship the packaging package, which is a dependency for Sphinx. * The version of the pygments package is different and the sets of files differs. * We ship the requests package, which is a dependency for Sphinx. * We ship the snowballstemmer package, which is a dependency for Sphinx. * We ship the urllib3 package, which is a dependency for requests, which is a dependency for Sphinx. * We ship a newer version of the futures package, which includes a handful of extra modules that match Python 3 module names. # no-check-commit because foo_bar naming Differential Revision: https://phab.mercurial-scm.org/D6097
Gregory Szorc -
r42087:4371f543 default
Show More
Name Size Modified Last Commit Author
/ contrib / docker / apache-server
Dockerfile Loading ...
README.rst Loading ...
entrypoint.sh Loading ...
hgwebconfig Loading ...
vhost.conf Loading ...

Apache Docker Server

This directory contains code for running a Mercurial hgweb server via mod_wsgi with the Apache HTTP Server inside a Docker container.

Important

This container is intended for testing purposes only: it is not meant to be suitable for production use.

Building Image

The first step is to build a Docker image containing Apache and mod_wsgi:

$ docker build -t hg-apache .

Important

You should rebuild the image whenever the content of this directory changes. Rebuilding after pulling or when you haven't run the container in a while is typically a good idea.

Running the Server

To run the container, you'll execute something like:

$ docker run --rm -it -v `pwd`/../../..:/var/hg/source -p 8000:80 hg-apache

If you aren't a Docker expert:

  • --rm will remove the container when it stops (so it doesn't clutter your system)
  • -i will launch the container in interactive mode so stdin is attached
  • -t will allocate a pseudo TTY
  • -v src:dst will mount the host filesystem at src into dst in the container. In our example, we assume you are running from this directory and use the source code a few directories up.
  • -p 8000:80 will publish port 80 on the container to port 8000 on the host, allowing you to access the HTTP server on the host interface.
  • hg-apache is the container image to run. This should correspond to what we build with docker build.

Important

The container requires that /var/hg/source contain the Mercurial source code.

Upon start, the container will attempt an install of the source in that directory. If the architecture of the host machine doesn't match that of the Docker host (e.g. when running Boot2Docker under OS X), Mercurial's Python C extensions will fail to run. Be sure to make clean your host's source tree before mounting it in the container to avoid this.

When starting the container, you should see some start-up actions (including a Mercurial install) and some output saying Apache has started:

Now if you load http://localhost:8000/ (or whatever interface Docker is using), you should see hgweb running!

For your convenience, we've created an empty repository available at /repo. Feel free to populate it with hg push.

Customizing the Server

By default, the Docker container installs a basic hgweb config and an empty dummy repository. It also uses some reasonable defaults for mod_wsgi.

Customizing the WSGI Dispatcher And Mercurial Config

By default, the Docker environment installs a custom hgweb.wsgi file (based on the example in contrib/hgweb.wsgi). The file is installed into /var/hg/htdocs/hgweb.wsgi.

A default hgweb configuration file is also installed. The hgwebconfig file from this directory is installed into /var/hg/htdocs/config.

You have a few options for customizing these files.

The simplest is to hack up hgwebconfig and entrypoint.sh in this directory and to rebuild the Docker image. This has the downside that the Mercurial working copy is modified and you may accidentally commit unwanted changes.

The next simplest is to copy this directory somewhere, make your changes, then rebuild the image. No working copy changes involved.

The preferred solution is to mount a host file into the container and overwrite the built-in defaults.

For example, say we create a custom hgweb config file in ~/hgweb. We can start the container like so to install our custom config file:

$ docker run -v ~/hgweb:/var/hg/htdocs/config ...

You can do something similar to install a custom WSGI dispatcher:

$ docker run -v ~/hgweb.wsgi:/var/hg/htdocs/hgweb.wsgi ...

Managing Repositories

Repositories are served from /var/hg/repos by default. This directory is configured as a Docker volume. This means you can mount an existing data volume container in the container so repository data is persisted across container invocations. See https://docs.docker.com/userguide/dockervolumes/ for more.

Alternatively, if you just want to perform lightweight repository manipulation, open a shell in the container:

$ docker exec -it <container> /bin/bash

Then run hg init, etc to manipulate the repositories in /var/hg/repos.

mod_wsgi Configuration Settings

mod_wsgi settings can be controlled with the following environment variables.

WSGI_PROCESSES
Number of WSGI processes to run.
WSGI_THREADS
Number of threads to run in each WSGI process
WSGI_MAX_REQUESTS
Maximum number of requests each WSGI process may serve before it is reaped.

See https://code.google.com/p/modwsgi/wiki/ConfigurationDirectives#WSGIDaemonProcess for more on these settings.

Note

The default is to use 1 thread per process. The reason is that Mercurial doesn't perform well in multi-threaded mode due to the GIL. Most people run a single thread per process in production for this reason, so that's what we default to.