// Find users which are inactive for more than 'diff'

			BOOST_FOREACH(User *u, (*it)->users) {

				if (now - u->getLastActivity() > diff) {

					usersToMove.push_back(u);

				}

			}

		}

		// Move inactive users to long-running backend.

		BOOST_FOREACH(User *u, usersToMove) {

			LOG4CXX_INFO(logger, "Moving user " << u->getJID().toString() << " to long-running backend");

			if (!moveToLongRunBackend(u))

				break;

		}

	}

	// We have to remove startingBackend flag otherwise 1 broken backend start could

	// block the backend.

	m_startingBackend = false;

	// check ping responses

	std::vector<Backend *> toRemove;

	for (std::list<Backend *>::const_iterator it = m_clients.begin(); it != m_clients.end(); it++) {

		// pong has been received OR backend just connected and did not have time to answer the ping

		// request.

		if ((*it)->pongReceived || (*it)->pongReceived == -1) {

			// Don't send another ping if pongReceived == -1, because we've already sent one

			// when registering backend.

			if ((*it)->pongReceived) {

				sendPing((*it));

			}

		}

		else {

			LOG4CXX_INFO(logger, "Disconnecting backend " << (*it) << " (ID=" << (*it)->id << "). PING response not received.");

			toRemove.push_back(*it);

		}

		if ((*it)->users.size() == 0) {

			LOG4CXX_INFO(logger, "Disconnecting backend " << (*it) << " (ID=" << (*it)->id << "). There are no users.");

			toRemove.push_back(*it);

		}

	}

	BOOST_FOREACH(Backend *b, toRemove) {

		handleSessionFinished(b);

	}

	m_pingTimer->start();

}

void NetworkPluginServer::collectBackend() {

	// Stop accepting new users to backend with the biggest memory usage. This prevents backends

	// which are leaking to eat whole memory by connectin new users to legacy network.

	LOG4CXX_INFO(logger, "Collect backend called, finding backend which will be set to die");

	unsigned long max = 0;

	Backend *backend = NULL;

	for (std::list<Backend *>::const_iterator it = m_clients.begin(); it != m_clients.end(); it++) {

		if ((*it)->res > max) {

			max = (*it)->res;

			backend = (*it);

		}

	}

	if (backend) {

		if (m_collectTimer) {

			m_collectTimer->start();

		}

		LOG4CXX_INFO(logger, "Backend " << backend << " (ID=" << backend->id << ") is set to die");

		backend->acceptUsers = false;

	}

}

bool NetworkPluginServer::moveToLongRunBackend(User *user) {

	// Check if user has already some backend

	Backend *old = (Backend *) user->getData();

	if (!old) {

		LOG4CXX_INFO(logger, "User " << user->getJID().toString() << " does not have old backend. Not moving.");

		return true;

	}

	// if he's already on long run, do nothing

	if (old->longRun) {

		LOG4CXX_INFO(logger, "User " << user->getJID().toString() << " is already on long-running backend. Not moving.");

		return true;

	}

	// Get free longrun backend, if there's no longrun backend, create one and wait

	// for its connection

	Backend *backend = getFreeClient(false, true);

	if (!backend) {

		LOG4CXX_INFO(logger, "No free long-running backend for user " << user->getJID().toString() << ". Will try later");

		return false;

	}

	// old backend will trigger disconnection which has to be ignored to keep user online

	user->setIgnoreDisconnect(true);

	// remove user from the old backend

	// If backend is empty, it will be collected by pingTimeout

	old->users.remove(user);

	// switch to new backend and connect

	user->setData(backend);

	backend->users.push_back(user);

	// connect him

	handleUserReadyToConnect(user);

	return true;

}

void NetworkPluginServer::handleUserCreated(User *user) {

	// Get free backend to handle this user or spawn new one if there's no free one.

	Backend *c = getFreeClient();

	// Add user to queue if there's no free backend to handle him so far.

	if (!c) {

		LOG4CXX_INFO(logger, "There is no backend to handle user " << user->getJID().toString() << ". Adding him to queue.");

		m_waitingUsers.push_back(user);

		return;

	}

	// Associate users with backend

	user->setData(c);

	c->users.push_back(user);

	// Don't forget to disconnect these in handleUserDestroyed!!!

	user->onReadyToConnect.connect(boost::bind(&NetworkPluginServer::handleUserReadyToConnect, this, user));

	user->onPresenceChanged.connect(boost::bind(&NetworkPluginServer::handleUserPresenceChanged, this, user, _1));

	user->onRoomJoined.connect(boost::bind(&NetworkPluginServer::handleRoomJoined, this, user, _1, _2, _3, _4));

	user->onRoomLeft.connect(boost::bind(&NetworkPluginServer::handleRoomLeft, this, user, _1));

}

void NetworkPluginServer::handleUserReadyToConnect(User *user) {

	UserInfo userInfo = user->getUserInfo();

	pbnetwork::Login login;

	login.set_user(user->getJID().toBare());

	login.set_legacyname(userInfo.uin);

	login.set_password(userInfo.password);

	std::string message;

	login.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_LOGIN);

	Backend *c = (Backend *) user->getData();

	if (!c) {

		return;

	}

	send(c->connection, message);

}

void NetworkPluginServer::handleUserPresenceChanged(User *user, Swift::Presence::ref presence) {

	if (presence->getShow() == Swift::StatusShow::None)

		return;

	UserInfo userInfo = user->getUserInfo();

	pbnetwork::Status status;

	status.set_username(user->getJID().toBare());

	bool isInvisible = presence->getPayload<Swift::InvisiblePayload>() != NULL;

	if (isInvisible) {

		LOG4CXX_INFO(logger, "This presence is invisible");

		status.set_status((pbnetwork::STATUS_INVISIBLE));

	}

	else {

		status.set_status((pbnetwork::StatusType) presence->getShow());

	}

	status.set_statusmessage(presence->getStatus());

	std::string message;

	status.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_STATUS_CHANGED);

	Backend *c = (Backend *) user->getData();

	if (!c) {

		return;

	}

	send(c->connection, message);

}

void NetworkPluginServer::handleRoomJoined(User *user, const Swift::JID &who, const std::string &r, const std::string &nickname, const std::string &password) {

	UserInfo userInfo = user->getUserInfo();

	pbnetwork::Room room;

	room.set_username(user->getJID().toBare());

	room.set_nickname(nickname);

	room.set_room(r);

	room.set_password(password);

	std::string message;

	room.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_JOIN_ROOM);

	Backend *c = (Backend *) user->getData();

	if (!c) {

		return;

	}

	send(c->connection, message);

	NetworkConversation *conv = new NetworkConversation(user->getConversationManager(), r, true);

	conv->onMessageToSend.connect(boost::bind(&NetworkPluginServer::handleMessageReceived, this, _1, _2));

	conv->setNickname(nickname);

	conv->setJID(who);

}

void NetworkPluginServer::handleRoomLeft(User *user, const std::string &r) {

	UserInfo userInfo = user->getUserInfo();

	pbnetwork::Room room;

	room.set_username(user->getJID().toBare());

	room.set_nickname("");

	room.set_room(r);

	room.set_password("");

	std::string message;

	room.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_LEAVE_ROOM);

	Backend *c = (Backend *) user->getData();

	if (!c) {

		return;

	}

	send(c->connection, message);

	NetworkConversation *conv = (NetworkConversation *) user->getConversationManager()->getConversation(r);

	if (!conv) {

		return;

	}

	user->getConversationManager()->removeConversation(conv);

	delete conv;

}

void NetworkPluginServer::handleUserDestroyed(User *user) {

	m_waitingUsers.remove(user);

	UserInfo userInfo = user->getUserInfo();

	user->onReadyToConnect.disconnect(boost::bind(&NetworkPluginServer::handleUserReadyToConnect, this, user));

	user->onPresenceChanged.disconnect(boost::bind(&NetworkPluginServer::handleUserPresenceChanged, this, user, _1));

	user->onRoomJoined.disconnect(boost::bind(&NetworkPluginServer::handleRoomJoined, this, user, _1, _2, _3, _4));

	user->onRoomLeft.disconnect(boost::bind(&NetworkPluginServer::handleRoomLeft, this, user, _1));

	pbnetwork::Logout logout;

	logout.set_user(user->getJID().toBare());

	logout.set_legacyname(userInfo.uin);

	std::string message;

	logout.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_LOGOUT);

	Backend *c = (Backend *) user->getData();

	if (!c) {

		return;

	}

	send(c->connection, message);

	c->users.remove(user);

	// If backend should handle only one user, it must not accept another one before 

	// we kill it, so set up willDie to true

	if (c->users.size() == 0 && CONFIG_INT(m_config, "service.users_per_backend") == 1) {

		LOG4CXX_INFO(logger, "Backend " << c->id << " will die, because the last user disconnected");

		c->willDie = true;

	}

}

void NetworkPluginServer::handleMessageReceived(NetworkConversation *conv, boost::shared_ptr<Swift::Message> &msg) {

	conv->getConversationManager()->getUser()->updateLastActivity();

	boost::shared_ptr<Swift::ChatState> statePayload = msg->getPayload<Swift::ChatState>();

	if (statePayload) {

		pbnetwork::WrapperMessage_Type type = pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED;

		switch (statePayload->getChatState()) {

			case Swift::ChatState::Active:

				type = pbnetwork::WrapperMessage_Type_TYPE_BUDDY_STOPPED_TYPING;

				break;

			case Swift::ChatState::Composing:

				type = pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPING;

				break;

			case Swift::ChatState::Paused:

				type = pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPED;

				break;

			default:

				break;

		}

		if (type != pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED) {

			pbnetwork::Buddy buddy;

			buddy.set_username(conv->getConversationManager()->getUser()->getJID().toBare());

			buddy.set_buddyname(conv->getLegacyName());

			std::string message;

			buddy.SerializeToString(&message);

			WRAP(message, type);

			Backend *c = (Backend *) conv->getConversationManager()->getUser()->getData();

			if (!c) {

				return;

			}

			send(c->connection, message);

		}

	}

	boost::shared_ptr<Swift::AttentionPayload> attentionPayload = msg->getPayload<Swift::AttentionPayload>();

	if (attentionPayload) {

		pbnetwork::ConversationMessage m;

		m.set_username(conv->getConversationManager()->getUser()->getJID().toBare());

		m.set_buddyname(conv->getLegacyName());

		m.set_message(msg->getBody());

		std::string message;

		m.SerializeToString(&message);

		WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_ATTENTION);

		Backend *c = (Backend *) conv->getConversationManager()->getUser()->getData();

		send(c->connection, message);

		return;

	}

	std::string xhtml;

	boost::shared_ptr<Swift::XHTMLIMPayload> xhtmlPayload = msg->getPayload<Swift::XHTMLIMPayload>();

	if (xhtmlPayload) {

		xhtml = xhtmlPayload->getBody();

	}

	// Send normal message

	if (!msg->getBody().empty() || !xhtml.empty()) {

		pbnetwork::ConversationMessage m;

		m.set_username(conv->getConversationManager()->getUser()->getJID().toBare());

		m.set_buddyname(conv->getLegacyName());

		m.set_message(msg->getBody());

		m.set_xhtml(xhtml);

		std::string message;

		m.SerializeToString(&message);

		WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_CONV_MESSAGE);

		Backend *c = (Backend *) conv->getConversationManager()->getUser()->getData();

		if (!c) {

			return;

		}

		send(c->connection, message);

	}

}

void NetworkPluginServer::handleBuddyRemoved(Buddy *b) {

	User *user = b->getRosterManager()->getUser();

	pbnetwork::Buddy buddy;

	buddy.set_username(user->getJID().toBare());

	buddy.set_buddyname(b->getName());

	buddy.set_alias(b->getAlias());

	BOOST_FOREACH(const std::string &g, b->getGroups()) {

		buddy.add_group(g);

	}

	buddy.set_status(pbnetwork::STATUS_NONE);

	std::string message;

	buddy.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_REMOVED);

	Backend *c = (Backend *) user->getData();

	if (!c) {

		return;

	}

	send(c->connection, message);

}

void NetworkPluginServer::handleBuddyUpdated(Buddy *b, const Swift::RosterItemPayload &item) {

	User *user = b->getRosterManager()->getUser();

	dynamic_cast<LocalBuddy *>(b)->setAlias(item.getName());

	dynamic_cast<LocalBuddy *>(b)->setGroups(item.getGroups());

	pbnetwork::Buddy buddy;

	buddy.set_username(user->getJID().toBare());

	buddy.set_buddyname(b->getName());

	buddy.set_alias(b->getAlias());

	BOOST_FOREACH(const std::string &g, b->getGroups()) {

		buddy.add_group(g);

	}

	buddy.set_status(pbnetwork::STATUS_NONE);

	std::string message;

	buddy.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED);

	Backend *c = (Backend *) user->getData();

	if (!c) {

		return;

	}

	send(c->connection, message);

}

void NetworkPluginServer::handleBuddyAdded(Buddy *buddy, const Swift::RosterItemPayload &item) {

	handleBuddyUpdated(buddy, item);

}

void NetworkPluginServer::handleBlockToggled(Buddy *b) {

	User *user = b->getRosterManager()->getUser();

	pbnetwork::Buddy buddy;

	buddy.set_username(user->getJID().toBare());

	buddy.set_buddyname(b->getName());

	buddy.set_alias(b->getAlias());

	BOOST_FOREACH(const std::string &g, b->getGroups()) {

		buddy.add_group(g);

	}

	buddy.set_status(pbnetwork::STATUS_NONE);

	buddy.set_blocked(!b->isBlocked());

	std::string message;

	buddy.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED);

	Backend *c = (Backend *) user->getData();

	if (!c) {

		return;

	}

	send(c->connection, message);

}

void NetworkPluginServer::handleVCardUpdated(User *user, boost::shared_ptr<Swift::VCard> v) {

	pbnetwork::VCard vcard;

	vcard.set_username(user->getJID().toBare());

	vcard.set_buddyname("");

	vcard.set_id(0);

	vcard.set_photo(&v->getPhoto()[0], v->getPhoto().size());

	vcard.set_nickname(v->getNickname());

	std::string message;

	vcard.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_VCARD);

	Backend *c = (Backend *) user->getData();

	if (!c) {

		return;

	}

	send(c->connection, message);

}

void NetworkPluginServer::handleVCardRequired(User *user, const std::string &name, unsigned int id) {

	pbnetwork::VCard vcard;

	vcard.set_username(user->getJID().toBare());

	vcard.set_buddyname(name);

	vcard.set_id(id);

	std::string message;

	vcard.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_VCARD);

	Backend *c = (Backend *) user->getData();

	if (!c) {

		return;

	}

	send(c->connection, message);

}

void NetworkPluginServer::handleFTAccepted(User *user, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long ftID) {

	pbnetwork::File f;

	f.set_username(user->getJID().toBare());

	f.set_buddyname(buddyName);

	f.set_filename(fileName);

	f.set_size(size);

	f.set_ftid(ftID);

	std::string message;

	f.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_FT_START);

	Backend *c = (Backend *) user->getData();

	if (!c) {

		return;

	}

	send(c->connection, message);

}

void NetworkPluginServer::handleFTRejected(User *user, const std::string &buddyName, const std::string &fileName, unsigned long size) {

	pbnetwork::File f;

	f.set_username(user->getJID().toBare());

	f.set_buddyname(buddyName);

	f.set_filename(fileName);

	f.set_size(size);

	f.set_ftid(0);

	std::string message;

	f.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_FT_FINISH);

	Backend *c = (Backend *) user->getData();

	if (!c) {

		return;

	}

	send(c->connection, message);

}

void NetworkPluginServer::handleFTStateChanged(Swift::FileTransfer::State state, const std::string &userName, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long id) {

	User *user = m_userManager->getUser(userName);

	if (!user) {

		// TODO: FIXME We have to remove filetransfer when use disconnects

		return;

	}

	if (state.state == Swift::FileTransfer::State::Transferring) {

		handleFTAccepted(user, buddyName, fileName, size, id);

	}

	else if (state.state == Swift::FileTransfer::State::Canceled) {

		handleFTRejected(user, buddyName, fileName, size);

	}

}

void NetworkPluginServer::sendPing(Backend *c) {

	std::string message;

	pbnetwork::WrapperMessage wrap;

	wrap.set_type(pbnetwork::WrapperMessage_Type_TYPE_PING);

	wrap.SerializeToString(&message);

	if (c->connection) {

		LOG4CXX_INFO(logger, "PING to " << c << " (ID=" << c->id << ")");

		send(c->connection, message);

		c->pongReceived = false;

	}

// 	LOG4CXX_INFO(logger, "PING to " << c);

}

NetworkPluginServer::Backend *NetworkPluginServer::getFreeClient(bool acceptUsers, bool longRun) {

	NetworkPluginServer::Backend *c = NULL;

	// Check all backends and find free one

	for (std::list<Backend *>::const_iterator it = m_clients.begin(); it != m_clients.end(); it++) {

		if ((*it)->willDie == false && (*it)->acceptUsers == acceptUsers && (*it)->users.size() < CONFIG_INT(m_config, "service.users_per_backend") && (*it)->connection && (*it)->longRun == longRun) {

			c = *it;

			// if we're not reusing all backends and backend is full, stop accepting new users on this backend

			if (!CONFIG_BOOL(m_config, "service.reuse_old_backends")) {

				if (c->users.size() + 1 >= CONFIG_INT(m_config, "service.users_per_backend")) {

					c->acceptUsers = false;

				}

			}

			break;

		}

	}

	// there's no free backend, so spawn one.

	if (c == NULL && !m_startingBackend) {

		m_isNextLongRun = longRun;

		m_startingBackend = true;

		exec_(CONFIG_STRING(m_config, "service.backend"), CONFIG_STRING(m_config, "service.backend_host").c_str(), CONFIG_STRING(m_config, "service.backend_port").c_str(), m_config->getConfigFile().c_str());

	}

	return c;

}

}

/**

 * XMPP - libpurple transport

 *

 * Copyright (C) 2009, Jan Kaluza <hanzz@soc.pidgin.im>

 *

 * 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/rosterstorage.h"

#include "transport/buddy.h"

#include "transport/user.h"

#include "transport/storagebackend.h"

namespace Transport {

// static void save_settings(gpointer k, gpointer v, gpointer data) {

// 	PurpleValue *value = (PurpleValue *) v;

// 	std::string key((char *) k);

// 	SaveData *s = (SaveData *) data;

// 	AbstractUser *user = s->user;

// 	long id = s->id;

// 	if (purple_value_get_type(value) == PURPLE_TYPE_BOOLEAN) {

// 		if (purple_value_get_boolean(value))

// 			Transport::instance()->sql()->addBuddySetting(user->storageId(), id, key, "1", purple_value_get_type(value));

// 		else

// 			Transport::instance()->sql()->addBuddySetting(user->storageId(), id, key, "0", purple_value_get_type(value));

// 	}

// 	else if (purple_value_get_type(value) == PURPLE_TYPE_STRING) {

// 		const char *str = purple_value_get_string(value);

// 		Transport::instance()->sql()->addBuddySetting(user->storageId(), id, key, str ? str : "", purple_value_get_type(value));

// 	}

// }

// 

// static gboolean storeAbstractSpectrumBuddy(gpointer key, gpointer v, gpointer data) {

// 	AbstractUser *user = (AbstractUser *) data;

// 	AbstractSpectrumBuddy *s_buddy = (AbstractSpectrumBuddy *) v;

// 	if (s_buddy->getFlags() & SPECTRUM_BUDDY_IGNORE)

// 		return TRUE;

// 	

// 	// save PurpleBuddy

// 	std::string alias = s_buddy->getAlias();

// 	std::string name = s_buddy->getName();

// 	long id = s_buddy->getId();

// 

// 	// Buddy is not in DB

// 	if (id != -1) {

// 		Transport::instance()->sql()->addBuddy(user->storageId(), name, s_buddy->getSubscription(), s_buddy->getGroup(), alias, s_buddy->getFlags());

// 	}

// 	else {

// 		id = Transport::instance()->sql()->addBuddy(user->storageId(), name, s_buddy->getSubscription(), s_buddy->getGroup(), alias, s_buddy->getFlags());

// 		s_buddy->setId(id);

// 	}

// 	Log("buddyListSaveNode", id << " " << name << " " << alias << " " << s_buddy->getSubscription());

// 	if (s_buddy->getBuddy() && id != -1) {

// 		PurpleBuddy *buddy = s_buddy->getBuddy();

// 		SaveData *s = new SaveData;

// 		s->user = user;

// 		s->id = id;

// 		g_hash_table_foreach(buddy->node.settings, save_settings, s);

// 		delete s;

// 	}

// 	return TRUE;

// }

RosterStorage::RosterStorage(User *user, StorageBackend *storageBackend) {

	m_user = user;

	m_storageBackend = storageBackend;

	m_storageTimer = m_user->getComponent()->getNetworkFactories()->getTimerFactory()->createTimer(5000);

	m_storageTimer->onTick.connect(boost::bind(&RosterStorage::storeBuddies, this));

}

RosterStorage::~RosterStorage() {

	m_storageTimer->stop();

}

void RosterStorage::removeBuddy(Buddy *buddy) {

	if (buddy->getID() != -1) {

		m_storageBackend->removeBuddy(buddy->getID());

	}

}

void RosterStorage::storeBuddy(Buddy *buddy) {

	if (!buddy) {

		return;

	}

	if (buddy->getName().empty()) {

		return;

	}

	m_buddies[buddy->getName()] = buddy;

	m_storageTimer->start();

}

bool RosterStorage::storeBuddies() {

	if (m_buddies.size() == 0) {

		return false;

	}

	m_storageBackend->beginTransaction();

	for (std::map<std::string, Buddy *>::const_iterator it = m_buddies.begin(); it != m_buddies.end(); it++) {

		Buddy *buddy = (*it).second;

		BuddyInfo buddyInfo;

		buddyInfo.alias = buddy->getAlias();

		buddyInfo.legacyName = buddy->getName();

		buddyInfo.groups = buddy->getGroups();

		buddyInfo.subscription = buddy->getSubscription() == Buddy::Ask ? "ask" : "both";

		buddyInfo.id = buddy->getID();

		buddyInfo.flags = buddy->getFlags();

		buddyInfo.settings["icon_hash"].s = buddy->getIconHash();

		buddyInfo.settings["icon_hash"].type = TYPE_STRING;

		// Buddy is in DB

		if (buddyInfo.id != -1) {

			m_storageBackend->updateBuddy(m_user->getUserInfo().id, buddyInfo);

		}

		else {

			buddyInfo.id = m_storageBackend->addBuddy(m_user->getUserInfo().id, buddyInfo);

			buddy->setID(buddyInfo.id);

		}

// 		Log("buddyListSaveNode", id << " " << name << " " << alias << " " << s_buddy->getSubscription());

// 		if (s_buddy->getBuddy() && id != -1) {

// 			PurpleBuddy *buddy = s_buddy->getBuddy();

// 			SaveData *s = new SaveData;

// 			s->user = user;

// 			s->id = id;

// 			g_hash_table_foreach(buddy->node.settings, save_settings, s);

// 			delete s;

// 		}

	}

	m_buddies.clear();

	m_storageBackend->commitTransaction();

	return true;

}

void RosterStorage::removeBuddyFromQueue(Buddy *buddy) {

	m_buddies.erase(buddy->getName());

}

}