Prerequisites

=============

1. Microsoft Visual C++ 2010 Express or higher edition (http://www.microsoft.com/visualstudio/en-us/products/2010-editions/visual-cpp-express)

2. Git for Windows (http://code.google.com/p/msysgit/downloads/list)

3. CMake 2.8 or newer (http://www.cmake.org/cmake/resources/software.html)

Libraries

=========

4. Boost 1.48 or newer (http://sourceforge.net/projects/boost/files/boost/1.49.0/)

5. Google ProtoBuf library (http://code.google.com/p/protobuf/downloads/list)

Environment

===========

To create spectrum build environment do:

0. Create directory where we'll install all dependencies, e.g. C:\env-msvc-x64.

Create C:\env-msvc-x64\bin and add it to %PATH%.

Assuming you have git, python and cmake in %PATH%, 

launch "Visual Studio 2010 command prompt" or

"Visual Studio 2010(x64) command prompt", depends on your target (Windows x86 or Windows x86_64).

1. unpack and build boost libraries:

	bootstrap.bat

	b2.exe --without-mpi --without-python

	b2.exe --without-mpi --without-python install --prefix=C:\env-msvc-x64 release

2. clone swift repository and build it. Don't forget to point it to our env directory:

	git clone git://swift.im/swift

	cd swift

	echo boost_includedir="c:/env-msvc-x64/include/boost-1_49" > config.py

	echo boost_libdir="c:/env-msvc-x64/lib" >> config.py 

	scons.bat debug=no SWIFTEN_INSTALLDIR=C:\env-msvc-x64 force_configure=1

	scons.bat debug=no SWIFTEN_INSTALLDIR=C:\env-msvc-x64 C:\env-msvc-x64

3. unpack and compile protobuf as described in its documentation. 

Run extract_includes.bat in vsprojects/ directory and move resulting vsprojects/include/google/ directory to our C:\env-msvc-x64\include

Move protoc.exe to C:\env-msvc-x64\bin\ and libprotobuf.lib to C:\env-msvc-x64\lib

4. Install gtkmm

Download installer from https://live.gnome.org/gtkmm/MSWindows and install gtkmm into C:\env-msvc-x64\

5. Install libpurple headers

Download http://www.pidgin.im/download/source/ , extract it and copy libpurple directory in C:\env-msvc-x64\include

6. You're ready! :) Clone libtransport into C:\env-msvc-x64\libtransport (You *must* clone it into this directory, because libtransport will try to find the dependencies in ../lib and ../include)

Compile it as:

	set CMAKE_INCLUDE_PATH=C:\env-msvc-x64\include

	nmake

/**

 * libtransport -- C++ library for easy XMPP Transports development

 *

 * Copyright (C) 2011, Jan Kaluza <hanzz.k@gmail.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA

 */

#include "transport/logging.h"

#include "transport/config.h"

#include "transport/util.h"

#include <boost/foreach.hpp>

#include <iostream>

#include <iterator>

#include <algorithm>

#include <boost/filesystem.hpp>

#include <boost/algorithm/string.hpp>

#ifndef WIN32

#include "sys/signal.h"

#include <sys/stat.h>

#include <pwd.h>

#include <grp.h>

#include <sys/resource.h>

#include "libgen.h"

#else

#include <windows.h>

#include <process.h>

#define getpid _getpid

#endif

using namespace boost::filesystem;

namespace Transport {

namespace Logging {

#ifdef WITH_LOG4CXX

using namespace log4cxx;

static LoggerPtr root;

class intercept_stream : public std::streambuf{

public:

    intercept_stream(std::ostream& stream, char const* logger):

      _logger(log4cxx::Logger::getLogger(logger))

    {

		stream.rdbuf(this);

    }

    ~intercept_stream(){

    }

protected:

    virtual std::streamsize xsputn(const char *msg, std::streamsize count){

        //Output to log4cxx logger

        std::string s(msg, count - 1); // remove last \n

		LOG4CXX_INFO(_logger, s);

        return count;

    }

	int overflow(int c)

	{

		return 0;

	}

	int sync()

	{

		return 0;

	}

private:

    log4cxx::LoggerPtr _logger;

};

static intercept_stream* intercepter_cout;

static intercept_stream* intercepter_cerr;

static void initLogging(Config *config, std::string key, bool only_create_dir = false) {

	if (CONFIG_STRING(config, key).empty()) {

		if (only_create_dir) {

			return;

		}

		root = log4cxx::Logger::getRootLogger();

#ifdef _MSC_VER

		root->addAppender(new ConsoleAppender(new PatternLayout(L"%d %-5p %c: %m%n")));

#else

		root->addAppender(new ConsoleAppender(new PatternLayout("%d %-5p %c: %m%n")));

#endif

	}

	else {

		log4cxx::helpers::Properties p;

		log4cxx::helpers::FileInputStream *istream = NULL;

		try {

			istream = new log4cxx::helpers::FileInputStream(CONFIG_STRING(config, key));

		}

		catch(log4cxx::helpers::IOException &ex) {

			std::cerr << "Can't create FileInputStream logger instance: " << ex.what() << "\n";

		}

		catch (...) {

			std::cerr << "Can't create FileInputStream logger instance\n";

		}

		if (!istream) {

			return;

		}

		p.load(istream);

		LogString pid, jid, id;

		log4cxx::helpers::Transcoder::decode(boost::lexical_cast<std::string>(getpid()), pid);

		log4cxx::helpers::Transcoder::decode(CONFIG_STRING(config, "service.jid"), jid);

		log4cxx::helpers::Transcoder::decode(CONFIG_STRING_DEFAULTED(config, "service.backend_id", ""), id);

#ifdef _MSC_VER

		p.setProperty(L"pid", pid);

		p.setProperty(L"jid", jid);

		p.setProperty(L"id", id);

#else

		p.setProperty("pid", pid);

		p.setProperty("jid", jid);

		p.setProperty("id", id);

#endif

		std::vector<std::string> dirs;

		BOOST_FOREACH(const log4cxx::LogString &prop, p.propertyNames()) {

			if (boost::ends_with(prop, ".File")) {

				std::string dir;

				log4cxx::helpers::Transcoder::encode(p.get(prop), dir);

				boost::replace_all(dir, "${jid}", jid);

				boost::replace_all(dir, "${pid}", pid);

				boost::replace_all(dir, "${id}", id);

				dirs.push_back(dir);

			}

		}

		mode_t old_cmask;

		// create directories

		old_cmask = umask(0007);

#endif

		BOOST_FOREACH(std::string &dir, dirs) {

			if (!dir.empty()) {

				try {

					Transport::Util::createDirectories(config, boost::filesystem::path(dir).parent_path());

				}

				catch (const boost::filesystem::filesystem_error &e) {

					std::cerr << "Can't create logging directory directory " << boost::filesystem::path(dir).parent_path().string() << ": " << e.what() << ".\n";

				}

			}

		}

#ifndef WIN32

		umask(old_cmask);

#endif

		if (only_create_dir) {

			return;

		}

		log4cxx::PropertyConfigurator::configure(p);

		// Change owner of main log file

#ifndef WIN32

	BOOST_FOREACH(std::string &dir, dirs) {

		if (!CONFIG_STRING(config, "service.group").empty() && !CONFIG_STRING(config, "service.user").empty()) {

			struct group *gr;

			if ((gr = getgrnam(CONFIG_STRING(config, "service.group").c_str())) == NULL) {

				std::cerr << "Invalid service.group name " << CONFIG_STRING(config, "service.group") << "\n";

			}

			struct passwd *pw;

			if ((pw = getpwnam(CONFIG_STRING(config, "service.user").c_str())) == NULL) {

				std::cerr << "Invalid service.user name " << CONFIG_STRING(config, "service.user") << "\n";

			}

			chown(dir.c_str(), pw->pw_uid, gr->gr_gid);

		}

	}

#endif

	}

}

void initBackendLogging(Config *config) {

	initLogging(config, "logging.backend_config");

	redirect_stderr();

}

void initMainLogging(Config *config) {

	initLogging(config, "logging.config");

	initLogging(config, "logging.backend_config", true);

}

void redirect_stderr() {

	 intercepter_cerr = new intercept_stream(std::cerr, "cerr");

	 intercepter_cout = new intercept_stream(std::cout, "cout");

}

void shutdownLogging() {

	delete intercepter_cerr;

	delete intercepter_cout;

	log4cxx::LogManager::shutdown();

}

#else /* WITH_LOG4CXX */

void initBackendLogging(Config */*config*/) {

}

void initMainLogging(Config */*config*/) {

}

void shutdownLogging() {

}

void redirect_stderr() {

}

#endif /* WITH_LOG4CXX */

}

}

#include "main.h"

#include <cppunit/CompilerOutputter.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <cppunit/TestResult.h>

#include <cppunit/TestResultCollector.h>

#include <cppunit/TestRunner.h>

#include <cppunit/BriefTestProgressListener.h>

#ifdef WITH_LOG4CXX

#include "log4cxx/logger.h"

#include "log4cxx/fileappender.h"

#include "log4cxx/patternlayout.h"

#include "log4cxx/propertyconfigurator.h"

using namespace log4cxx;

#endif

int main (int argc, char* argv[])

{

#ifdef WITH_LOG4CXX

	LoggerPtr root = Logger::getRootLogger();

	root->addAppender(new FileAppender(new PatternLayout("%d %-5p %c: %m%n"), "libtransport_test.log", false));

#endif

	std::vector<std::string> testsToRun;

	for (int i = 1; i < argc; ++i) {

		std::string param(argv[i]);

		testsToRun.push_back(param);

	}

	if (testsToRun.empty()) {

		testsToRun.push_back("");

	}

	// informs test-listener about testresults

	CPPUNIT_NS :: TestResult testresult;

	// register listener for collecting the test-results

	CPPUNIT_NS :: TestResultCollector collectedresults;

	testresult.addListener (&collectedresults);

	// register listener for per-test progress output

	CPPUNIT_NS :: BriefTestProgressListener progress;

	testresult.addListener (&progress);

	// insert test-suite at test-runner by registry

	CPPUNIT_NS :: TestRunner testrunner;

	testrunner.addTest (CPPUNIT_NS :: TestFactoryRegistry :: getRegistry ().makeTest ());

	for (std::vector<std::string>::const_iterator i = testsToRun.begin(); i != testsToRun.end(); ++i) {

		try {

			testrunner.run(testresult, *i);

		}

		catch (const std::exception& e) {

			std::cerr << "Error: " << e.what() << std::endl;

			return -1;

		}

	}

	// output results in compiler-format

	CPPUNIT_NS :: CompilerOutputter compileroutputter (&collectedresults, std::cerr);

	compileroutputter.write ();

	// return 0 if tests were successful

	return collectedresults.wasSuccessful () ? 0 : 1;

}