Config.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;

import com.juniform.JUniform;
import com.juniform.JUniformObject;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.naming.directory.InvalidAttributesException;
import ragefist.core.distribution.DistributedServer;
import ragefist.core.distribution.DistributedServer.DistributedServerBuilder;
import ragefist.core.distribution.DistributedServerGroup;
import ragefist.core.distribution.DistributedServerGroup.DistributedServerGroupBuilder;
import ragefist.core.distribution.SelectionPolicy;

/**
 *
 * @author acherkashin
 */
public class Config
{
	// ---------------------------------------------------------------------- //
	// CONFIG FILES
	// ---------------------------------------------------------------------- //
	public static final String CONFIG_FILE_SERVER = "./config/Server.json";
	
	// ---------------------------------------------------------------------- //
	// CONFIG VARIABLES
	// ---------------------------------------------------------------------- //
	public static String LuaEnvironmentConnectorFile;
	public static String LuaEnvironmentMainFile;
	
	public static String ServerGroup;
	public static int ServerId;
	
	public static String RPCPacketFormat;
	public static String ClientPacketFormat;
	public static String HTTPClientPacketFormat;
	
	public static HashMap<String,DistributedServerGroup> ServerGroups = new HashMap<>();
	public static DistributedServerGroup CurrentServerGroup;
	public static DistributedServer CurrentServer;
	
	public static String[] Extensions;
	
	public static boolean DisableCrossEnvironmentInteraction;
	public static boolean IsTestServer;
	
	// ---------------------------------------------------------------------- //
	// LOADING
	// ---------------------------------------------------------------------- //
	
	public static void load() {
		final JUniformObject serverCfg = _loadConfigByFileName(CONFIG_FILE_SERVER);
		
		// LUA
		LuaEnvironmentConnectorFile = serverCfg.getProperty("LuaEnvironmentConnectorFile").toStringDefault("Connector.lua");
		LuaEnvironmentMainFile = serverCfg.getProperty("LuaEnvironmentMainFile").toStringDefault("Loader.lua");
		
		// Server Settings
		ServerId = serverCfg.getProperty("ServerId").toIntegerDefault(0);
		ServerGroup = serverCfg.getProperty("ServerGroup").toString();
		if (ServerGroup == null) {
			Logger.getLogger(Config.class.getName()).severe("There is no ServerGroup param in ["+CONFIG_FILE_SERVER+"] file");
			return;
		}
		
		// Packet Formats
		RPCPacketFormat        = serverCfg.getProperty("RPCPacketFormat").toStringDefault(JUniform.PACKER_TYPE_JSON);
		ClientPacketFormat     = serverCfg.getProperty("ClientPacketFormat").toStringDefault(JUniform.PACKER_TYPE_JSON);
		HTTPClientPacketFormat = serverCfg.getProperty("HTTPClientPacketFormat").toStringDefault(JUniform.PACKER_TYPE_JSON);
		
		DisableCrossEnvironmentInteraction = serverCfg.getProperty("DisableCrossEnvironmentInteraction").toBooleanDefault(false);
		IsTestServer = serverCfg.getProperty("IsTestServer").toBooleanDefault(false);
		
		// ------------------------------ //
		// Extensions
		// ------------------------------ //
		ArrayList<String> extensions = new ArrayList<>();
		Iterator<JUniformObject> extensionsIt = serverCfg.getProperty("Extensions").iterator();
		while(extensionsIt.hasNext()) {
			extensions.add(extensionsIt.next().toString());
		}
		Config.Extensions = new String[extensions.size()];
		extensions.toArray(Config.Extensions);
		
		// ------------------------------ //
		// PARSING SERVER GROUPS
		// ------------------------------ //
		
		DistributedServerGroupBuilder serverGroupBuilder = new DistributedServerGroupBuilder();
		DistributedServerBuilder serverBuilder = new DistributedServerBuilder();
		
		// Server groups
		JUniformObject serverGroupsNode = serverCfg.getProperty("ServerGroups");
		if (serverGroupsNode.isNull()) {
			Logger.getLogger(Config.class.getName()).severe("There is no ServerGroups param in ["+CONFIG_FILE_SERVER+"] file");
			return;
		}
		
		Iterator<JUniformObject> serverGroupsIt = serverGroupsNode.iterator();
		while(serverGroupsIt.hasNext()) {
			// Reset builder
			serverGroupBuilder.code    = null;
			serverGroupBuilder.servers = new ArrayList<>();
			
			// Parse
			JUniformObject serverGroupNode = serverGroupsIt.next();
			
			serverGroupBuilder.code = serverGroupNode.getProperty("Code").toString();
			if (serverGroupBuilder.code == null) {
				Logger.getLogger(Config.class.getName()).severe("GroupName param for ServerGroup item is not specified in ["+CONFIG_FILE_SERVER+"] file");
				return;
			}
			
			JUniformObject serverSelectionPolicyNode = serverGroupNode.getProperty("SelectionPolicy");
			try {
				serverGroupBuilder.selectionPolicy = SelectionPolicy.newInstance(serverSelectionPolicyNode);
			} catch (InvalidAttributesException ex) {
				Logger.getLogger(Config.class.getName()).log(Level.SEVERE, 
					"Failed to determine what environment selection policy should be used in ServerGroup ["+serverGroupBuilder.code+"]", ex
				);
				return;
			}
			
			JUniformObject serversNode = serverGroupNode.getProperty("Servers");
			if (serversNode == null) {
				Logger.getLogger(Config.class.getName()).severe("GroupName param for ServerGroup item is not specified in ["+CONFIG_FILE_SERVER+"] file");
				return;
			}
			
			int serverId = 0;
			Iterator<JUniformObject> serversIt = serversNode.iterator();
			while(serversIt.hasNext()) {
				JUniformObject serverNode = serversIt.next();
				
				// Server's config
				int environmentCount = serverNode.getProperty("EnvironmentCount").toIntegerDefault(1);
				JUniformObject environmentSelectionPolicyNode = serverNode.getProperty("SelectionPolicy");
				try {
					serverBuilder.selectionPolicy = SelectionPolicy.newInstance(environmentSelectionPolicyNode);
				} catch (InvalidAttributesException ex) {
					Logger.getLogger(Config.class.getName()).log(Level.SEVERE, 
						"Failed to determine what environment selection policy should be used in ServerGroup ["+serverGroupBuilder.code+"]", ex
					);
					return;
				}
				
				// Builder
				serverBuilder.id = serverId++;
				serverBuilder.environmentCount = environmentCount;
				serverBuilder.rpcHost = serverNode.getProperty("RPCServerHost").toStringDefault("127.0.0.1");
				serverBuilder.rpcPort = serverNode.getProperty("RPCServerPort").toIntegerDefault(15600);
				serverBuilder.rpcPacketFormat = RPCPacketFormat;
				
				serverBuilder.consoleHost = serverNode.getProperty("ConsoleServerHost").toStringDefault("127.0.0.1");
				serverBuilder.consolePort = serverNode.getProperty("ConsoleServerPort").toIntegerDefault(15600);
				serverBuilder.clientHost = serverNode.getProperty("ClientServerHost").toStringDefault("127.0.0.1");
				serverBuilder.clientPort = serverNode.getProperty("ClientServerPort").toIntegerDefault(16000);
				serverBuilder.clientPacketFormat = ClientPacketFormat;
				
				serverBuilder.httpClientHost = serverNode.getProperty("HTTPClientServerHost").toStringDefault(null);
				serverBuilder.httpClientPort = serverNode.getProperty("HTTPClientServerPort").toIntegerDefault(0);
				serverBuilder.httpClientPacketFormat = HTTPClientPacketFormat;
				
				serverBuilder.environmentLuaConnectorFile = Config.LuaEnvironmentConnectorFile;
				serverBuilder.environmentLuaMainFile = Config.LuaEnvironmentMainFile;
				
				// Create a server
				try {
					serverGroupBuilder.servers.add(serverBuilder.build());
				} catch (IllegalArgumentException ex) {
					Logger.getLogger(Config.class.getName()).log(Level.SEVERE, "Failed to build DistributedServer", ex);
					return;
				}
			}
			
			DistributedServerGroup serverGroup;
			try {
				// Constructing server group
				serverGroup = serverGroupBuilder.build();
			} catch (InvalidAttributesException ex) {
				Logger.getLogger(Config.class.getName()).log(Level.SEVERE, "Failed to build DistributedServerGroup", ex);
				return;
			}
			
			// Save groups
			ServerGroups.put(serverGroup.getCode(), serverGroup);
		}
		
		// Get current server's data
		CurrentServerGroup = ServerGroups.get(ServerGroup);
		if (CurrentServerGroup == null) {
			Logger.getLogger(Config.class.getName()).log(Level.SEVERE, "Failed to find CurrentServerGroup");
			return;
		}
		CurrentServer = CurrentServerGroup.getServers().get(ServerId);
		if (CurrentServer == null) {
			Logger.getLogger(Config.class.getName()).log(Level.SEVERE, "Failed to find CurrentServer");
			return;
		}
	}
	
	// ---------------------------------------------------------------------- //
	// PRIVATE
	// ---------------------------------------------------------------------- //
	private static JUniformObject _loadConfigByFileName(String fileName) {
		File file = new File(fileName);
        try (FileInputStream fileInputStream = new FileInputStream(file)) {
			return JUniform.getPackerInstance(JUniform.PACKER_TYPE_JSON).toUniformObjectFromStream(fileInputStream);
        }
        catch (IOException e) {
            Logger.getLogger(Config.class.getName()).warning("[" + file.getName() + "] Failed to load JSON config due to the reason: " + e.getMessage());
        }
		return null;
	}
}