PacketHandlerClient.java

/*
 * Created by Andrey Cherkashin (acherkashin)
 * http://acherkashin.me
 * 
 * License
 * Copyright (c) 2015 Andrey Cherkashin
 * The project released under the MIT license: http://opensource.org/licenses/MIT
 */
package ragefist.packets;

import com.juniform.JUniformMutableObject;
import com.juniform.JUniformObject;
import java.util.HashMap;
import org.luaj.vm2.LuaValue;
import ragefist.User;
import ragefist.core.ProcessorTask;
import ragefist.core.distribution.DistributedServerController.DistributedServerControllerAPI;
import ragefist.core.distribution.DistributedServerPacketHandler;
import ragefist.core.environment.EnvironmentRequestTask;
import ragefist.core.network.Connection;
import ragefist.core.util.FormatTools;
import ragefist.packets.client.Request;

/**
 *
 * @author acherkashin
 */
public class PacketHandlerClient extends DistributedServerPacketHandler
{
	private final HashMap<Integer,Connection> _tasksWaitingResponseMap = new HashMap<>();
	private final IncomingPacket.IncomingPacketBuilder _packetBuilder;

	public PacketHandlerClient(DistributedServerControllerAPI serverControllerAPI) {
		super(serverControllerAPI);
		
		_packetBuilder = new IncomingPacket.IncomingPacketBuilder();
		_packetBuilder.packetHandler = this;
	}
	
	public Class<? extends IncomingPacket> getPacketClassForAction(String action) throws IncomingPacketException {
		switch(action) {
			default:
				return Request.class;
		}
	}
	
	@Override
	public void handleConnection(Connection connection) {
		User user = new User();
		
		// Determine what Environment should be used for that user in that session
		user.setEnvironmentId(
			_serverControllerAPI.getSelectionPolicy().select(
				_serverControllerAPI.getEnvironmentCount()
			)
		);
		
		// Attach user
		connection.setAttachment(user);
	}
	
	@Override
	public void handlePacket(JUniformObject packet, Connection connection) {
		Integer sq = null;
		try {
			String action = packet.getProperty("action").toString();
			if (action == null) {
				throw new IncomingPacketException("ERROR_UNKNOWN_ACTION");
			}
			sq = packet.getProperty("sq").toInteger();
			
			_packetBuilder.packet = packet;
			_packetBuilder.action = action;
			_packetBuilder.sq = sq;
			_packetBuilder.connection = connection;
			
			// CREATE A PACKET
			Class<? extends IncomingPacket> packetClass = getPacketClassForAction(action);
			IncomingPacket packetExecutor = _packetBuilder.build(packetClass);
			
			// EXECUTING
			packetExecutor.run();
		}
		catch (IncomingPacketException ex) {
			JUniformMutableObject result = JUniformMutableObject.newMap();
			result.setProperty("rs", 0);
			result.setProperty("error", ex.getCode());
			
			if (this.getServerControllerAPI().isTestServer()) {
				result.setProperty("debug", ex.getMessage());
			}
			
			if (sq != null) result.setProperty("sq", sq);
			connection.sendPacket(result);
		}
	}

	// ---------------------------------------------------------------------- //
	// IEnvironmentTaskDelegate
	// ---------------------------------------------------------------------- //
	
	@Override
	public void whenTaskIsFinished(ProcessorTask task) {
		EnvironmentRequestTask requestTask = (EnvironmentRequestTask)task;
		Connection connection = requestTask.getConnection();
		if (connection.isClosed()) {
			return;
		}
		
		JUniformObject resp;
		if (task.getResult()) {
			resp = FormatTools.fromLuaToJUniformObject((LuaValue)task.getData());
		} else {
			JUniformMutableObject respMutable = JUniformMutableObject.newMap();
			respMutable.setProperty("rs", 0);
			if (task.getData() != null) {
				respMutable.setProperty("data", FormatTools.fromLuaToJUniformObject((LuaValue)task.getData()));
			}
			if (task.getError() != null) {
				respMutable.setProperty("error", task.getError());
			}
			resp = respMutable;
		}
		connection.sendPacket(resp);
	}
	
	@Override
	public void whenIncomingPacketIsFinished(IncomingPacket packet, boolean status, Object responseData) {
		
	}
}