/** \mainpage MaxScale by MariaDB Corporation

The MariaDB Corporation MaxScale is an intelligent proxy that allows forwarding of
database statements to one or more database servers using complex rules,
a semantic understanding of the database statements and the roles of
the various servers within the backend cluster of databases.

MaxScale is designed to provide load balancing and high availability
functionality transparently to the applications. In addition it provides
a highly scalable and flexibile architecture, with plugin components to
support different protocols and routing decissions.

MaxScale is implemented in C and makes extensive use of the
asynchronous I/O capabilities of the Linux operating system. The epoll
system is used to provide the event driven framework for the input and
output via sockets.

The protocols are implemented as external shared object modules which
can be loaded at runtime. These modules support a fixed interface,
communicating the entries points via a structure consisting of a set of
function pointers. This structure is called the "module object".

The code that routes the queries to the database servers is also loaded
as external shared objects and are referred to as routing modules.

An Google Group exists for MaxScale that can be used to discuss ideas,
issues and communicate with the MaxScale community.
	Send email to [maxscale@googlegroups.com](mailto:maxscale@googlegroups.com)
	or use the [forum](http://groups.google.com/forum/#!forum/maxscale) interface
	
Bugs can be reported in the MariaDB Corporation bugs database
	[bug.mariadb.com](http://bugs.mariadb.com)

\section Dependency List

Before building MaxScale from source, make sure you have installed all the dependencies for your system.
To install MariaDB packages configure MariaDB repositories for your system:
 see instruction [here](https://downloads.mariadb.org/mariadb/repositories/) 
The full list of dependencies for the most common distros:

All RHEL, CentOS and Fedora versions:

      gcc gcc-c++ ncurses-devel bison glibc-devel cmake libgcc perl make libtool 
      openssl-devel libaio libaio-devel librabbitmq-devel

RHEL 6, 7, CentOS 6, 7, Fedora:

     libedit-devel

RHEL 7, CentOS 7:

     mariadb-devel mariadb-embedded-devel 

RHEL 5, 7, CentOS 5, 6, Fedora 19, 20

     MariaDB-devel MariaDB-server

Fedora 19, 20

       systemtap-sdt-devel

to build RPM package:

   rpm-build 

Ubuntu 14.04, Debian 'jessie'

       cmake
       gcc g++ ncurses-dev bison build-essential libssl-dev libaio-dev 
       perl make libtool librabbitmq-dev libmariadbclient-dev 
       libmariadbd-dev mariadb-server

Other Ubuntu and Debian
	
	MariaDB embedded library have to be manually extracted from tarball:
	https://downloads.mariadb.org/interstitial/mariadb-5.5.41/bintar-linux-glibc_214-x86_64/mariadb-5.5.41-linux-glibc_214-x86_64.tar.gz
	for old systems with glibc < 2.14:
	https://downloads.mariadb.org/interstitial/mariadb-5.5.41/bintar-linux-x86_64/mariadb-5.5.41-linux-x86_64.tar.gz

To build DEB package:
   dpkg-dev

OpenSUSE (mariadb-devel package, build fails):
         gcc gcc-c++ ncurses-devel bison glibc-devel cmake libgcc_s1 perl 
         make libtool libopenssl-devel libaio libaio-devel 
         libedit-devel librabbitmq-devel
 	 MariaDB-devel MariaDB-client MariaDB-server (if zypper ask which MariaDB client should be installed 'MariaDB-client' or 'mariadb-client'
	 please select 'MariaDB-client')


If you do not wish to install the MariaDB packages you can use the bundled RPM unpacking script:

	./unpack_rpm.sh <location of MariaDB RPMs> <extraction destination>   

This looks for MariaDB RPMs and unpacks them into the destination directory. This location
can then be passed to CMake to specify the location of the headers, libraries and other required files.

\section Building Building MaxScale

Once you have installed all of MaxScale's dependencies you are ready to build MaxScale using CMake.

CMake tries to find all the required directories and files on its own but if it can't find them or you wish to
explicitly state the locations you can pass additional options to CMake by using the -D flag. To confirm the variable
values, you can run CMake in interactive mode by using the -i flag or use a CMake GUI (for example, ccmake for command line).

It is highly recommended to make a separate build directory to build into. 
This keeps the source and build trees clean and makes it easy to get rid 
of everything you built by simply deleting the build directory.

To build MaxScale using CMake:

		cd <path to MaxScale source>

		mkdir build

		cd build

		cmake ..

		make

		make install

This generates the required makefiles in the current directory, compiles 
and links all the programs and installs
all the required files in their right places.

If you have your headers and libraries in non-standard locations, you can 
define those locations at configuration time as such:

		cmake -D<variable>=<value>


This libmysqld.a comes from the RPM or it is copied from an existing
MariaDB setup. The file embedded_priv.h is not available in the RPM
packages, please get it from an existing MariaDB setup and copy it
to one of the path in MYSQL_HEADERS

The ERRMSG variable points to the errmsg.sys file that is required
by the embedded library. If you unpacked the RPMs using the script
you need to provide the location of the errmsg.sys file when you
are configuring the build system.

Example:

	cmake -DERRMSG=/home/user/share/english/errmsg.sys ..


Please note the errmsg.sys file is NOT included in the RPMs at the
current time, it must be taken from an existing MariaDB setup. The
version of the errmsg.sys file must match the version of the developer
package you are using. A version mismatch will cause the library to fail
to initialise.

By default, MaxScale installs to '/usr/local/skysql/maxscale' and places init.d scripts 
and ldconfig files into their folders. Change the CMAKE_INSTALL_PREFIX variable to your desired 
installation directory and set INSTALL_SYSTEM_FILES=N to prevent the init.d script and 
ldconfig file installation.

If you run into any trouble while configuring CMake, you can always remove the 
'CMakeCache.txt' file to clear CMake's internal cache. This resets all values to their 
defaults and can be used to fix a 'stuck' configuration of CMake. This is also a good 
reason why you should always build into a separate directory, because you can safely 
wipe the build directory clean without the danger of deleting important files when 
something goes wrong. Building 'out-of-source' also allows you to have multiple 
configurations of MaxScale at the same time.

The default values that CMake uses can be found in the 'macros.cmake' file. 
If you wish to change these, edit the 'macros.cmake' file or define the 
variables manually at configuration time.

To display all CMake variables with their descriptions:

   cmake -LH <path to source>

\section Running  Running MaxScale

MaxScale consists of a core executable and a number of modules that implement
the different protocols and routing algorithms. These modules are built as
shared objects that are loaded on demand. In order for MaxScale to find these
modules it will search using a predescribed search path. The rules are:

1. Look in the current directory for the module

2. Look in $MAXSCALE_HOME/modules

3. Look in /usr/local/skysql/maxscale/modules

Configuration is read by default from the file
$MAXSCALE_HOME/etc/MaxScale.cnf, /etc/MaxScale.cnf, an example file
is included in in the installation and can be found in the etc/ folder. 
The default value of MAXSCALE_HOME can be overriden by using the -c flag 
on the command line. This should be immediately followed by the path to 
the MaxScale home directory.

The -f flag can be used to set the name and the location of the configuration 
file. Without path expression the file is read from $MAXSCALE_HOME/etc directory.

\section Testing  Running MaxScale testsuite

To run "make testall" you need to have four mysqld servers running
on localhost. It assumes a master-slave replication setup with one slave and
three slaves.

The ports to which these servers are listening and the credentials to use for testing
 can be specified in the 'macros.cmake' file.

On the master full privileges on the databases "test" and "FOO"
are needed, on the saves SELECT permissions on test.* should
be sufficient.

When you run the 'make testall' target after configuring the build with CMake
a local version of MaxScale is installed into the build folder. After this a MaxScale
instance is started and the test set is executed. 

After testing has finished you can find a full testlog 
generated by CTest in Testing/Temporary/ directory and MaxScale's 
log files in the log/ directory of the build root.

*/