// Parse wrapper message and erase it from buffer.

		pbnetwork::WrapperMessage wrapper;

		if (wrapper.ParseFromArray(&_data[4], expected_size) == false) {

			std::cout << "PARSING ERROR " << expected_size << "\n";

			_data.erase(_data.begin(), _data.begin() + 4 + expected_size);

			continue;

		}

		_data.erase(_data.begin(), _data.begin() + 4 + expected_size);

		if (wrapper.type() == pbnetwork::WrapperMessage_Type_TYPE_QUERY) {

			pbnetwork::BackendConfig payload;

			if (payload.ParseFromString(wrapper.payload()) == false) {

				std::cout << "PARSING ERROR\n";

				// TODO: ERROR

				continue;

			}

			std::cout << payload.config() << "\n";

			exit(0);

		}

	}

}

static void handleConnected(boost::shared_ptr<Swift::Connection> m_conn, const std::string &msg, bool error) {

	if (error) {

		std::cerr << "Can't connect the server\n";

		exit(50);

	}

	else {

		pbnetwork::BackendConfig m;

		m.set_config(msg);

		std::string message;

		m.SerializeToString(&message);

		WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_QUERY);

		uint32_t size = htonl(message.size());

		char *header = (char *) &size;

		// send header together with wrapper message

		m_conn->write(Swift::createSafeByteArray(std::string(header, 4) + message));

	}

}

static void ask_local_server(ManagerConfig *config, Swift::BoostNetworkFactories &networkFactories, const std::string &jid, const std::string &message) {

	path p(CONFIG_STRING(config, "service.config_directory"));

	try {

		if (!exists(p)) {

			std::cerr << "Config directory " << CONFIG_STRING(config, "service.config_directory") << " does not exist\n";

			exit(6);

		}

		if (!is_directory(p)) {

			std::cerr << "Config directory " << CONFIG_STRING(config, "service.config_directory") << " does not exist\n";

			exit(7);

		}

		bool found = false;

		directory_iterator end_itr;

		for (directory_iterator itr(p); itr != end_itr; ++itr) {

			if (is_regular(itr->path()) && extension(itr->path()) == ".cfg") {

				Config cfg;

				if (cfg.load(itr->path().string()) == false) {

					std::cerr << "Can't load config file " << itr->path().string() << ". Skipping...\n";

					continue;

				}

				if (CONFIG_STRING(&cfg, "service.jid") != jid) {

					continue;

				}

				found = true;

				boost::shared_ptr<Swift::Connection> m_conn;

				m_conn = networkFactories.getConnectionFactory()->createConnection();

				m_conn->onDataRead.connect(boost::bind(&handleDataRead, m_conn, _1));

				m_conn->onConnectFinished.connect(boost::bind(&handleConnected, m_conn, message, _1));

				m_conn->connect(Swift::HostAddressPort(Swift::HostAddress(CONFIG_STRING(&cfg, "service.backend_host")), getPort(CONFIG_STRING(&cfg, "service.portfile"))));

// 				finished++;

// 				Swift::Client *client = new Swift::Client(CONFIG_VECTOR(&cfg, "service.admin_jid")[0], CONFIG_STRING(&cfg, "service.admin_password"), &networkFactories);

// 				client->setAlwaysTrustCertificates();

// 				client->onConnected.connect(boost::bind(&handleConnected, client, CONFIG_STRING(&cfg, "service.jid")));

// 				client->onDisconnected.connect(bind(&handleDisconnected, client, _1, CONFIG_STRING(&cfg, "service.jid")));

// 				client->onMessageReceived.connect(bind(&handleMessageReceived, client, _1, CONFIG_STRING(&cfg, "service.jid")));

// 				Swift::ClientOptions opt;

// 				opt.allowPLAINWithoutTLS = true;

// 				client->connect(opt);

			}

		}

		if (!found) {

			std::cerr << "Config file for Spectrum instance with this JID was not found\n";

		}

	}

	catch (const filesystem_error& ex) {

		std::cerr << "boost filesystem error\n";

		exit(5);

	}

}

// static void ask_local_servers(ManagerConfig *config, Swift::BoostNetworkFactories &networkFactories, const std::string &message) {

// 	path p(CONFIG_STRING(config, "service.config_directory"));

// 

// 	try {

// 		if (!exists(p)) {

// 			std::cerr << "Config directory " << CONFIG_STRING(config, "service.config_directory") << " does not exist\n";

// 			exit(6);

// 		}

// 

// 		if (!is_directory(p)) {

// 			std::cerr << "Config directory " << CONFIG_STRING(config, "service.config_directory") << " does not exist\n";

// 			exit(7);

// 		}

// 

// 		directory_iterator end_itr;

// 		for (directory_iterator itr(p); itr != end_itr; ++itr) {

// 			if (is_regular(itr->path()) && extension(itr->path()) == ".cfg") {

// 				Config cfg;

// 				if (cfg.load(itr->path().string()) == false) {

// 					std::cerr << "Can't load config file " << itr->path().string() << ". Skipping...\n";

// 					continue;

// 				}

// 

// 				if (CONFIG_VECTOR(&cfg, "service.admin_jid").empty() || CONFIG_STRING(&cfg, "service.admin_password").empty()) {

// 					std::cerr << itr->path().string() << ": service.admin_jid or service.admin_password empty. This server can't be queried over XMPP.\n";

// 					continue;

// 				}

// 

// 				finished++;

// 				Swift::Client *client = new Swift::Client(CONFIG_VECTOR(&cfg, "service.admin_jid")[0], CONFIG_STRING(&cfg, "service.admin_password"), &networkFactories);

// 				client->setAlwaysTrustCertificates();

// 				client->onConnected.connect(boost::bind(&handleConnected, client, CONFIG_STRING(&cfg, "service.jid")));

// 				client->onDisconnected.connect(bind(&handleDisconnected, client, _1, CONFIG_STRING(&cfg, "service.jid")));

// 				client->onMessageReceived.connect(bind(&handleMessageReceived, client, _1, CONFIG_STRING(&cfg, "service.jid")));

// 				Swift::ClientOptions opt;

// 				opt.allowPLAINWithoutTLS = true;

// 				client->connect(opt);

// 			}

// 		}

// 	}

// 	catch (const filesystem_error& ex) {

// 		std::cerr << "boost filesystem error\n";

// 		exit(5);

// 	}

// }

int main(int argc, char **argv)

{

	ManagerConfig config;

	std::string config_file;

	std::vector<std::string> command;

	boost::program_options::variables_map vm;

	boost::program_options::options_description desc("Usage: spectrum [OPTIONS] <COMMAND>\n"

													 "       spectrum [OPTIONS] <instance_JID> <other>\nCommands:\n"

													 " start - start all local Spectrum2 instances\n"

													 " stop  - stop all local Spectrum2 instances\n"

													 " status - status of local Spectrum2 instances\n"

													 " <other> - send command to local Spectrum2 instance and print output\n"

													 "Allowed options");

	desc.add_options()

		("help,h", "Show help output")

		("config,c", boost::program_options::value<std::string>(&config_file)->default_value("/etc/spectrum2/spectrum_manager.cfg"), "Spectrum manager config file")

		("command", boost::program_options::value<std::vector<std::string> >(&command), "Command")

		;

	try

	{

		boost::program_options::positional_options_description p;

		p.add("command", -1);

		boost::program_options::store(boost::program_options::command_line_parser(argc, argv).

          options(desc).positional(p).run(), vm);

		boost::program_options::notify(vm);

		if(vm.count("help"))

		{

			std::cout << desc << "\n";

			return 1;

		}

	}

	catch (std::runtime_error& e)

	{

		std::cout << desc << "\n";

		return 2;

	}

	catch (...)

	{

		std::cout << desc << "\n";