path: root/src/rollback.cpp

/*
Minetest
Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/

#include "rollback.h"
#include <fstream>
#include <list>
#include <sstream>
#include "log.h"
#include "mapnode.h"
#include "gamedef.h"
#include "nodedef.h"
#include "util/serialize.h"
#include "util/string.h"
#include "util/numeric.h"
#include "inventorymanager.h" // deserializing InventoryLocations

#define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")"

#define POINTS_PER_NODE (16.0)

// Get nearness factor for subject's action for this action
// Return value: 0 = impossible, >0 = factor
static float getSuspectNearness(bool is_guess, v3s16 suspect_p, int suspect_t,
		v3s16 action_p, int action_t)
{
	// Suspect cannot cause things in the past
	if(action_t < suspect_t)
		return 0; // 0 = cannot be
	// Start from 100
	int f = 100;
	// Distance (1 node = -x points)
	f -= POINTS_PER_NODE * intToFloat(suspect_p, 1).getDistanceFrom(intToFloat(action_p, 1));
	// Time (1 second = -x points)
	f -= 1 * (action_t - suspect_t);
	// If is a guess, halve the points
	if(is_guess)
		f *= 0.5;
	// Limit to 0
	if(f < 0)
		f = 0;
	return f;
}

class RollbackManager: public IRollbackManager
{
public:
	// IRollbackManager interface

	void reportAction(const RollbackAction &action_)
	{
		// Ignore if not important
		if(!action_.isImportant(m_gamedef))
			return;
		RollbackAction action = action_;
		action.unix_time = time(0);
		// Figure out actor
		action.actor = m_current_actor;
		action.actor_is_guess = m_current_actor_is_guess;
		// If actor is not known, find out suspect or cancel
		if(action.actor.empty()){
			v3s16 p;
			if(!action.getPosition(&p))
				return;
			action.actor = getSuspect(p, 83, 1);
			if(action.actor.empty())
				return;
			action.actor_is_guess = true;
		}
		infostream<<"RollbackManager::reportAction():"
				<<" time="<<action.unix_time
				<<" actor=\""<<action.actor<<"\""
				<<(action.actor_is_guess?" (guess)":"")
				<<" action="<<action.toString()
				<<std::endl;
		addAction(action);
	}
	std::string getActor()
	{
		return m_current_actor;
	}
	bool isActorGuess()
	{
		return m_current_actor_is_guess;
	}
	void setActor(const std::string &actor, bool is_guess)
	{
		m_current_actor = actor;
		m_current_actor_is_guess = is_guess;
	}
	std::string getSuspect(v3s16 p, float nearness_shortcut, float min_nearness)
	{
		if(m_current_actor != "")
			return m_current_actor;
		int cur_time = time(0);
		int first_time = cur_time - (100-min_nearness);
		RollbackAction likely_suspect;
		float likely_suspect_nearness = 0;
		for(std::list<RollbackAction>::const_reverse_iterator
				i = m_action_latest_buffer.rbegin();
				i != m_action_latest_buffer.rend(); i++)
		{
			if(i->unix_time < first_time)
				break;
			if(i->actor == "")
				continue;
			// Find position of suspect or continue
			v3s16 suspect_p;
			if(!i->getPosition(&suspect_p))
				continue;
			float f = getSuspectNearness(i->actor_is_guess, suspect_p,
					i->unix_time, p, cur_time);
			if(f >= min_nearness && f > likely_suspect_nearness){
				likely_suspect_nearness = f;
				likely_suspect = *i;
				if(likely_suspect_nearness >= nearness_shortcut)
					break;
			}
		}
		// No likely suspect was found
		if(likely_suspect_nearness == 0)
			return "";
		// Likely suspect was found
		return likely_suspect.actor;
	}
	void flush()
	{
		infostream<<"RollbackManager::flush()"<<std::endl;
		std::ofstream of(m_filepath.c_str(), std::ios::app);
		if(!of.good()){
			errorstream<<"RollbackManager::flush(): Could not open file "
					<<"for appending: \""<<m_filepath<<"\""<<std::endl;
			return;
		}
		for(std::list<RollbackAction>::const_iterator
				i = m_action_todisk_buffer.begin();
				i != m_action_todisk_buffer.end(); i++)
		{
			// Do not save stuff that does not have an actor
			if(i->actor == "")
				continue;
			of<<i->unix_time;
			of<<" ";
			of<<serializeJsonString(i->actor);
			of<<" ";
			of<<i->toString();
			if(i->actor_is_guess){
				of<<" ";
				of<<"actor_is_guess";
			}
			of<<std::endl;
		}
		m_action_todisk_buffer.clear();
	}
	
	// Other

	RollbackManager(const std::string &filepath, IGameDef *gamedef):
		m_filepath(filepath),
		m_gamedef(gamedef),
		m_current_actor_is_guess(false)
	{
		infostream<<"RollbackManager::RollbackManager("<<filepath<<")"
				<<std::endl;
	}
	~RollbackManager()
	{
		infostream<<"RollbackManager::~RollbackManager()"<<std::endl;
		flush();
	}

	void addAction(const RollbackAction &action)
	{
		m_action_todisk_buffer.push_back(action);
		m_action_latest_buffer.push_back(action);

		// Flush to disk sometimes
		if(m_action_todisk_buffer.size() >= 100)
			flush();
	}
	
	bool readFile(std::list<RollbackAction> &dst)
	{
		// Load whole file to memory
		std::ifstream f(m_filepath.c_str(), std::ios::in);
		if(!f.good()){
			errorstream<<"RollbackManager::readFile(): Could not open "
					<<"file for reading: \""<<m_filepath<<"\""<<std::endl;
			return false;
		}
		for(;;){
			if(f.eof() || !f.good())
				break;
			std::string line;
			std::getline(f, line);
			line = trim(line);
			if(line == "")
				continue;
			std::istringstream is(line);
			
			try{
				std::string action_time_raw;
				std::getline(is, action_time_raw, ' ');
				std::string action_actor;
				try{
					action_actor = deSerializeJsonString(is);
				}catch(SerializationError &e){
					errorstream<<"RollbackManager: Error deserializing actor: "
							<<e.what()<<std::endl;
					throw e;
				}
				RollbackAction action;
				action.unix_time = stoi(action_time_raw);
				action.actor = action_actor;
				int c = is.get();
				if(c != ' '){
					is.putback(c);
					throw SerializationError("readFile(): second ' ' not found");
				}
				action.fromStream(is);
				/*infostream<<"RollbackManager::readFile(): Action from disk: "
						<<action.toString()<<std::endl;*/
				dst.push_back(action);
			}
			catch(SerializationError &e){
				errorstream<<"RollbackManager: Error on line: "<<line<<std::endl;
				errorstream<<"RollbackManager: ^ error: "<<e.what()<<std::endl;
			}
		}
		return true;
	}

	std::list<RollbackAction> getEntriesSince(int first_time)
	{
		infostream<<"RollbackManager::getEntriesSince("<<first_time<<")"<<std::endl;
		// Collect enough data to this buffer
		std::list<RollbackAction> action_buffer;
		// Use the latest buffer if it is long enough
		if(!m_action_latest_buffer.empty() &&
				m_action_latest_buffer.begin()->unix_time <= first_time){
			action_buffer = m_action_latest_buffer;
		}
		else
		{
			// Save all remaining stuff
			flush();
			// Load whole file to memory
			bool good = readFile(action_buffer);
			if(!good){
				errorstream<<"RollbackManager::getEntriesSince(): Failed to"
						<<" open file; using data in memory."<<std::endl;
				action_buffer = m_action_latest_buffer;
			}
		}
		return action_buffer;
	}
	
	std::string getLastNodeActor(v3s16 p, int range, int seconds,
			v3s16 *act_p, int *act_seconds)
	{
		infostream<<"RollbackManager::getLastNodeActor("<<PP(p)
				<<", "<<seconds<<")"<<std::endl;
		// Figure out time
		int cur_time = time(0);
		int first_time = cur_time - seconds;

		std::list<RollbackAction> action_buffer = getEntriesSince(first_time);
		
		std::list<RollbackAction> result;

		for(std::list<RollbackAction>::const_reverse_iterator
				i = action_buffer.rbegin();
				i != action_buffer.rend(); i++)
		{
			if(i->unix_time < first_time)
				break;

			// Find position of action or continue
			v3s16 action_p;
			if(!i->getPosition(&action_p))
				continue;

			if(range == 0){
				if(action_p != p)
					continue;
			} else {
				if(abs(action_p.X - p.X) > range ||
						abs(action_p.Y - p.Y) > range ||
						abs(action_p.Z - p.Z) > range)
					continue;
			}
			
			if(act_p)
				*act_p = action_p;
			if(act_seconds)
				*act_seconds = cur_time - i->unix_time;
			return i->actor;
		}
		return "";
	}

	std::list<RollbackAction> getRevertActions(const std::string &actor_filter,
			int seconds)
	{
		infostream<<"RollbackManager::getRevertActions("<<actor_filter
				<<", "<<seconds<<")"<<std::endl;
		// Figure out time
		int cur_time = time(0);
		int first_time = cur_time - seconds;
		
		std::list<RollbackAction> action_buffer = getEntriesSince(first_time);
		
		std::list<RollbackAction> result;

		for(std::list<RollbackAction>::const_reverse_iterator
				i = action_buffer.rbegin();
				i != action_buffer.rend(); i++)
		{
			if(i->unix_time < first_time)
				break;
			if(i->actor != actor_filter)
				continue;
			const RollbackAction &action = *i;
			/*infostream<<"RollbackManager::revertAction(): Should revert"
					<<" time="<<action.unix_time
					<<" actor=\""<<action.actor<<"\""
					<<" action="<<action.toString()
					<<std::endl;*/
			result.push_back(action);
		}

		return result;
	}

private:
	std::string m_filepath;
	IGameDef *m_gamedef;
	std::string m_current_actor;
	bool m_current_actor_is_guess;
	std::list<RollbackAction> m_action_todisk_buffer;
	std::list<RollbackAction> m_action_latest_buffer;
};

IRollbackManager *createRollbackManager(const std::string &filepath, IGameDef *gamedef)
{
	return new RollbackManager(filepath, gamedef);
}