<div class="wiki-content maincontent"><h2 id="Building-Dependencies">Dependencies</h2><h3 id="Building-libuuid">libuuid</h3><p>On *nix sytems, the build requires the libuuid library that is part of the e2fsprogs package and is available from <a shape="rect" class="external-link" href="http://e2fsprogs.sourceforge.net/" rel="nofollow">http://e2fsprogs.sourceforge.net/</a> which is not always installed by default.</p><p>On Fedora/Red Hat/openSUSE, you should install the e2fsprogs and e2fsprogs-devel packages. On Debian/Ubuntu, you should install uuid and uuid-dev packages.</p><h3 id="Building-CppUnit">CppUnit</h3><p>The package contains a complete set of CppUnit tests. In order for you to build an run the tests, you will need to download and install the CppUnit library. See <a shape="rect" class="external-link" href="http://cppunit.sourceforge.net/cppunit-wiki" rel="nofollow">http://cppunit.sourceforge.net/cppunit-wiki</a></p><p>On Fedora/Red Hat/openSUSE, you should install the cppunit and cppunit-devel packages. On Debian/Ubuntu, you should install the build-essential, libcppunit and libcppunit-dev packages.</p><p>Make sure that the paths to the installed CppUnit library and includes are visible in your current shell before you try building the tests.</p><p>Windows users will need to build the CppUnit library using the CppUnit MSVC project files. A discussion of the build process can be found on the CppUnit wiki under <a shape="rect" class="external-link" href="http://cppunit.sourceforge.net/cppunit-wiki/BuildingCppUnit1" rel="nofollow">CppUnit build instructions</a> this covers both MSVC along with many other platforms and tool suites.</p><h3 id="Building-APR">APR</h3><p>With versions of ActiveMQ-CPP 2.2 and later, we have a dependency on the <a shape="rect" class="external-link" href="http://apr.apache.org">Apache Portable Runtime</a> project. You'll need to install APR on your system before you'll be able to build ActiveMQ-CPP.</p><div class="confluence-information-macro confluence-information-macro-note"><p class="title">Note to Windows Vista/MSVC++ 2008 Users</p><span class="aui-icon aui-icon-small aui-iconfont-warning confluence-information-macro-icon"></span><div class="confluence-information-macro-body"><p>The Vista SDK has introduced some build problems for APR. For a work-around, follow the instructions <a shape="rect" class="external-link" href="https://issues.apache.org/bugzilla/show_bug.cgi?id=40398">here</a>.</p></div></div><h2 id="Building-Buildingon*nix(Unix/Linux/OSX/Cygwin)">Building on *nix (Unix/Linux/OS X/Cygwin)</h2><h3 id="Building-GNUBuildSystem(forbuildingon*nix)">GNU Build System (for building on *nix)</h3><p>To Generate the ./configure script use to create the Makefiles, you need the following software installed:</p><div class="table-wrap"><table class="confluenceTable"><tbody><tr><th colspan="1" rowspan="1" class="confluenceTh"><p>Tool</p></th><th colspan="1" rowspan="1" class="confluenceTh"><p>Recommended Version</p></th></tr><tr><td colspan="1" rowspan="1" class="confluenceTd"><p>autoconf</p></td><td colspan="1" rowspan="1" class="confluenceTd"><p>&gt;= 2.59</p></td></tr><tr><td colspan="1" rowspan="1" class="confluenceTd"><p>automake</p></td><td colspan="1" rowspan="1" class="confluenceTd"><p>&gt;= 1.9.6</p></td></tr><tr><td colspan="1" rowspan="1" class="confluenceTd"><p>libtool</p></td><td colspan="1" rowspan="1" class="confluenceTd"><p>&gt;= 1.5.22</p></td></tr></tbody></table></div><p>You can also install the Doxygen and Graphviz packages if you want to generate the API documentation in HTML format.</p><h3 id="Building-Building">Building</h3><p>This assumes you have all of the project dependencies installed. We're now ready to create the configure script. To do this, run:</p><div class="code panel pdl" style="border-width: 1px;"><div class="codeContent panelContent pdl">
<script class="brush: java; gutter: false; theme: Default" type="syntaxhighlighter"><![CDATA[./autogen.sh
]]></script>
</div></div><div class="confluence-information-macro confluence-information-macro-information"><span class="aui-icon aui-icon-small aui-iconfont-info confluence-information-macro-icon"></span><div class="confluence-information-macro-body"><p>You may see the following warnings when running this command:</p><p>src/test-integration/Makefile.am:44: `CXXFLAGS' is a user variable, you should not override it;<br clear="none"> src/test-integration/Makefile.am:44: use `AM_CXXFLAGS' instead.<br clear="none"> src/test/Makefile.am:104: `CXXFLAGS' is a user variable, you should not override it;<br clear="none"> src/test/Makefile.am:104: use `AM_CXXFLAGS' instead.</p><p>These can be ignored. We override CXXFLAGS in the makefiles for the unit and integration tests in order to suppress compiler warnings.</p></div></div><p>This should be run the first time and anytime you change configure.ac or any of the Makefile.am files.</p><div class="confluence-information-macro confluence-information-macro-information"><p class="title">Solaris 10 Note</p><span class="aui-icon aui-icon-small aui-iconfont-info confluence-information-macro-icon"></span><div class="confluence-information-macro-body"><p>CppUnit might not build until you correct the file libstdc++.la to contain the correct data, see this discussion.</p><p><a shape="rect" class="external-link" href="http://forum.sun.com/jive/thread.jspa?threadID=73150" rel="nofollow">http://forum.sun.com/jive/thread.jspa?threadID=73150</a></p></div></div><p>The configure script will customize the way the software is built and installed into your system along with detecting the available libraries that have been installed. To use the default configuration just run:</p><div class="code panel pdl" style="border-width: 1px;"><div class="codeContent panelContent pdl">
<script class="brush: java; gutter: false; theme: Default" type="syntaxhighlighter"><![CDATA[./configure
]]></script>
</div></div><p>For more help on how to customize the build configuration, run:</p><div class="code panel pdl" style="border-width: 1px;"><div class="codeContent panelContent pdl">
<script class="brush: java; gutter: false; theme: Default" type="syntaxhighlighter"><![CDATA[./configure --help
]]></script>
</div></div><p>Once the configure script has run successfully, you are ready to build. Run:</p><div class="code panel pdl" style="border-width: 1px;"><div class="codeContent panelContent pdl">
<script class="brush: java; gutter: false; theme: Default" type="syntaxhighlighter"><![CDATA[make
]]></script>
</div></div><p>This will build all of the core ActiveMQ CPP source code. To build and install the code into the system directories, run:</p><div class="code panel pdl" style="border-width: 1px;"><div class="codeContent panelContent pdl">
<script class="brush: java; gutter: false; theme: Default" type="syntaxhighlighter"><![CDATA[make install
]]></script>
</div></div><p>You will have to become the superuser in order to be able to install the files.</p><h3 id="Building-Doxygen">Doxygen</h3><p>To generate the doxygen documentation for the project, just run:</p><div class="code panel pdl" style="border-width: 1px;"><div class="codeContent panelContent pdl">
<script class="brush: java; gutter: false; theme: Default" type="syntaxhighlighter"><![CDATA[make doxygen-run
]]></script>
</div></div><h3 id="Building-RunningTests">Running Tests</h3><h3 id="Building-UnitTests">Unit Tests</h3><p>In order to build and run the suite of unit tests, run:</p><div class="code panel pdl" style="border-width: 1px;"><div class="codeContent panelContent pdl">
<script class="brush: java; gutter: false; theme: Default" type="syntaxhighlighter"><![CDATA[make check
]]></script>
</div></div><p>This will verify that the library is functioning correctly on the target platform. In addition, it will generate the integration tests binary.</p><h3 id="Building-IntegrationTests">Integration Tests</h3><p>The library also contains a set of tests that are run against a real AMQ broker. These allow you to validate this distribution of ActiveMQ CPP against your broker. Running these without a broker will result in failed tests. The tests currently hard-code the broker url to be tcp://localhost:61613 for stomp and tcp://localhost:61616 for openwire.</p><p>The integration tests are built via "make check". To run them, first start a broker and then</p><div class="code panel pdl" style="border-width: 1px;"><div class="codeContent panelContent pdl">
<script class="brush: java; gutter: false; theme: Default" type="syntaxhighlighter"><![CDATA[cd src/test-integration
./activemq-test-integration
]]></script>
</div></div><p>This will take quite some time to complete, so be patient.</p><h3 id="Building-Example">Example</h3><p>There is an example application that ships with the distribution in src/examples. The example is compiled by default with the "make" command, but can easily be compiled manually using the command similar to the following (varies by platform).</p><div class="code panel pdl" style="border-width: 1px;"><div class="codeContent panelContent pdl">
<script class="brush: java; gutter: false; theme: Default" type="syntaxhighlighter"><![CDATA[g++ -o main -pthread -I ../main main.cpp ../../src/main/.libs/libactivemq-cpp.a -luuid -I /usr/include/apr-1.0/ -lssl -lcrypto -lapr-1
]]></script>
</div></div><h2 id="Building-BuildingonWindowswithMSVC">Building on Windows with MSVC</h2><p>We support using the GNU compiler on Windows, using the Cygwin package. However we also support using the MSVC compiler on Windows.</p><p>There are a couple or things that you will need to setup to ensure that the MSVC compile succeeds.</p><h3 id="Building-IncludingDependencies">Including Dependencies</h3><p>The Project files reference the libraries described in the <a shape="rect" href="#Building-Dependencies">#Dependencies</a> section. To build successfully, you must either place these libraries in a directory listed in the project settings, or add a new location for your library directories.</p><h3 id="Building-MSVC&gt;=2008">MSVC &gt;= 2008</h3><p>If you're using MSVC &gt;= 2008, it comes with the Windows SDK (so you don't need to download it separately).</p><p>For ActiveMQ-CPP &gt;= 2.2, you will have to follow some special instructions for building APR, duscussed <a shape="rect" href="#Building-APR">here</a>.</p><h3 id="Building-Non-Vista/MSVC&lt;2008">Non-Vista/MSVC &lt; 2008</h3><p>If you are using Visual C++ &lt; 2008, you need to download and install the Platform SDK if you don't have it installed already (the Platform SDK is called the "Windows SDK" since the release of Windows Vista). Once installed, do the following:</p><ul><li>Ensure that the path to your MSVC install is set in the PATH env variable. You can test this by typing cl.exe at the command line, if you get an error complaining that it is not found, then you'll need to fix your PATH. Alternatively, you can set up the necessary environment variables by running C:\Program Files\Microsoft Visual Studio 8\Common7\Tools\vsvars32.bat.</li><li><p>Set the INCLUDE env variable to include the path to your MSVC includes, and the platform SDK includes. For example:</p><div class="code panel pdl" style="border-width: 1px;"><div class="codeContent panelContent pdl">
<script class="brush: java; gutter: false; theme: Default" type="syntaxhighlighter"><![CDATA[INCLUDE = D:\Program Files\Microsoft Visual Studio 8\VC\include;D:\Program Files\Microsoft Platform SDK\Include\*
]]></script>
</div></div></li><li><p>Set the LIB env variable to include the path to your MSVC libs, and the Platform SDK libs. For example:</p><div class="code panel pdl" style="border-width: 1px;"><div class="codeContent panelContent pdl">
<script class="brush: java; gutter: false; theme: Default" type="syntaxhighlighter"><![CDATA[LIB = D:\Program Files\Microsoft Visual Studio 8\VC\lib;D:\Program Files\Microsoft Platform SDK\Lib
]]></script>
</div></div></li></ul></div>

