server

Documentation - 1

Download Browse

+160 −89

Author

Debayan Sutradhar (rnayabed) 2021-01-31 23:36

Committer

Debayan Sutradhar (rnayabed) 2021-01-31 23:36

Hash 3471ed2e8bb4686f31ef3918ee0ae4aace825bc4

Parent faf84fb26aa2ce8a3a4ba5493c203e5fcac3d313

Reference git #server/3471ed2e8bb4686f31ef3918ee0ae4aace825bc4

Modified Files

List

Side by side diff

Inline diff

M src/main/java/com/StreamPi/Server/Action/NormalActionPlugins.java

+91 −25

Stream-Pi - Free & Open-Source Modular Cross-Platform Programmable Macropad

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 3 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.

Written by : Debayan Sutradhar (rnayabed)

package com.StreamPi.Server.Action;

import com.StreamPi.ActionAPI.Action.Action;

import com.StreamPi.ActionAPI.Action.ActionType;

import com.StreamPi.ActionAPI.Action.ServerConnection;

import com.StreamPi.ActionAPI.Action.PropertySaver;

import com.StreamPi.ActionAPI.ActionProperty.ClientProperties;

import com.StreamPi.ActionAPI.ActionProperty.Property.ControlType;

import com.StreamPi.ActionAPI.ActionProperty.Property.Property;

import com.StreamPi.ActionAPI.ActionProperty.Property.Type;

import com.StreamPi.ActionAPI.ActionProperty.ServerProperties;

import com.StreamPi.ActionAPI.NormalAction.NormalAction;

import com.StreamPi.Server.Controller.Controller;

import com.StreamPi.Util.Exception.MinorException;

import com.StreamPi.Util.Exception.SevereException;

import com.StreamPi.Util.Exception.StreamPiException;

import com.StreamPi.Util.Version.Version;

import com.StreamPi.Util.XMLConfigHelper.XMLConfigHelper;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.transform.Result;

import javax.xml.transform.Source;

import javax.xml.transform.Transformer;

import javax.xml.transform.TransformerFactory;

import javax.xml.transform.dom.DOMSource;

import javax.xml.transform.stream.StreamResult;

import javafx.scene.image.ImageView;

import org.w3c.dom.NodeList;

import org.kordamp.ikonli.javafx.FontIcon;

import org.w3c.dom.Document;

import org.w3c.dom.Node;

import java.io.File;

import java.lang.module.*;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.ServiceLoader;

import java.util.logging.Level;

import java.util.logging.Logger;

import java.util.stream.Collectors;

import org.w3c.dom.Element;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.transform.Transformer;

public class NormalActionPlugins

{

private static NormalActionPlugins instance = null;

private final Logger logger;

private File configFile;

private Document document;

private static String pluginsLocation = null;

/**

* Singleton class instance getter. Creates new one, when asked for the first time

* @return returns instance of NormalActionPlugins (one and only, always)

public static synchronized NormalActionPlugins getInstance()

{

if(instance == null)

{

instance = new NormalActionPlugins();

}

return instance;

}

/**

* Sets the folder location where the plugin JARs and their dependencies are stored

* @param location Folder location

public static void setPluginsLocation(String location)

{

pluginsLocation = location;

}

/**

* Private constructor

private NormalActionPlugins()

{

logger = Logger.getLogger(NormalActionPlugins.class.getName());

normalPluginsHashmap = new HashMap<>();

}

/**

* init Method

public void init() throws SevereException, MinorException

{

registerPlugins();

initPlugins();

}

/**

* Used to fetch list of all external Plugins

* @return List of plugins

public List<NormalAction> getPlugins()

{

return normalPlugins;

}

/**

* Returns a plugin by its module name

* @param name Module Name

* @return The plugin. If not found, then null is returned

public NormalAction getPluginByModuleName(String name)

{

logger.info("Plugin being requested : "+name);

Integer index = normalPluginsHashmap.getOrDefault(name, -1);

if(index != -1)

{

return normalPlugins.get(index);

}

return null;

}

private List<NormalAction> normalPlugins = null;

HashMap<String, Integer> normalPluginsHashmap;

/**

* Used to register plugins from plugin location

public void registerPlugins() throws SevereException, MinorException

{

logger.info("Registering external plugins from "+pluginsLocation+" ...");

try

{

configFile = new File(pluginsLocation+"/config.xml");

DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();

DocumentBuilder docBuilder = docFactory.newDocumentBuilder();

document = docBuilder.parse(configFile);

}

catch (Exception e)

{

e.printStackTrace();

throw new SevereException("Plugins","Error reading plugins config.xml. Cannot continue.");

}

ArrayList<NormalAction> errorModules = new ArrayList<>();

ArrayList<String> errorModuleError = new ArrayList<>();

ArrayList<Action> pluginsConfigs = new ArrayList<>();

NodeList actionsNode = document.getElementsByTagName("actions").item(0).getChildNodes();

for(int i =0;i<actionsNode.getLength();i++)

{

Node eachActionNode = actionsNode.item(i);

if(eachActionNode.getNodeType() != Node.ELEMENT_NODE)

continue;

if(!eachActionNode.getNodeName().equals("action"))

continue;

Element eachActionElement = (Element) eachActionNode;

String name="";

String name;

Version version;

try

{

name = XMLConfigHelper.getStringProperty(eachActionElement, "module-name");

version = new Version(XMLConfigHelper.getStringProperty(eachActionElement, "version"));

}

catch (Exception e)

{

logger.log(Level.WARNING, "Skipping configuration because invalid ...");

e.printStackTrace();

continue;

}

ServerProperties serverProperties = new ServerProperties();

NodeList serverPropertiesNodeList = eachActionElement.getElementsByTagName("properties").item(0).getChildNodes();

for(int j = 0;j<serverPropertiesNodeList.getLength();j++)

{

Node eachPropertyNode = serverPropertiesNodeList.item(j);

if(eachPropertyNode.getNodeType() != Node.ELEMENT_NODE)

continue;

if(!eachPropertyNode.getNodeName().equals("property"))

continue;

Element eachPropertyElement = (Element) eachPropertyNode;

try

{

Property property = new Property(XMLConfigHelper.getStringProperty(eachPropertyElement, "name"), Type.STRING);

property.setRawValue(XMLConfigHelper.getStringProperty(eachPropertyElement, "value"));

serverProperties.addProperty(property);

}

catch (Exception e)

{

logger.log(Level.WARNING, "Skipping property because invalid ...");

e.printStackTrace();

}

Action action = new Action(ActionType.NORMAL);

action.setModuleName(name);

action.setVersion(version);

action.getServerProperties().set(serverProperties);

pluginsConfigs.add(action);

}

logger.info("Size : "+pluginsConfigs.size());

Path pluginsDir = Paths.get(pluginsLocation); // Directory with plugins JARs

try

{

// Search for plugins in the plugins directory

ModuleFinder pluginsFinder = ModuleFinder.of(pluginsDir);

// Find all names of all found plugin modules

List<String> p = pluginsFinder

.findAll()

.stream()

.map(ModuleReference::descriptor)

.map(ModuleDescriptor::name)

.collect(Collectors.toList());

// Create configuration that will resolve plugin modules

// (verify that the graph of modules is correct)

Configuration pluginsConfiguration = ModuleLayer

.boot()

.configuration()

.resolve(pluginsFinder, ModuleFinder.of(), p);

// Create a module layer for plugins

ModuleLayer layer = ModuleLayer

.boot()

.defineModulesWithOneLoader(pluginsConfiguration, ClassLoader.getSystemClassLoader());

logger.info("Loading plugins from jar ...");

// Now you can use the new module layer to find service implementations in it

normalPlugins = ServiceLoader

.load(layer, NormalAction.class).stream()

.map(ServiceLoader.Provider::get)

.collect(Collectors.toList());

logger.info("...Done!");

}

catch (Exception e)

{

e.printStackTrace();

throw new MinorException("Error", "Error loading modules\n"+e.getMessage()+"\nPlease fix the errors. Other plugins wont be loaded.");

}

sortedPlugins = new HashMap<>();

for (NormalAction eachPlugin : normalPlugins) {

for (NormalAction eachPlugin : normalPlugins)

try {

{

try

{

eachPlugin.setPropertySaver(propertySaver);

eachPlugin.setServerConnection(serverConnection);

eachPlugin.initProperties();

Action foundAction = null;

for (Action action : pluginsConfigs) {

if (action.getModuleName().equals(eachPlugin.getModuleName())

&& action.getVersion().isEqual(eachPlugin.getVersion())) {

foundAction = action;

List<Property> eachPluginStoredProperties = action.getServerProperties().get();

List<Property> eachPluginCodeProperties = eachPlugin.getServerProperties().get();

for (int i =0;i< eachPluginCodeProperties.size(); i++) {

Property eachPluginCodeProperty = eachPluginCodeProperties.get(i);

Property foundProp = null;

for (Property eachPluginStoredProperty : eachPluginStoredProperties) {

if (eachPluginCodeProperty.getName().equals(eachPluginStoredProperty.getName())) {

eachPluginCodeProperty.setRawValue(eachPluginStoredProperty.getRawValue());

foundProp = eachPluginStoredProperty;

}

eachPluginCodeProperties.set(i, eachPluginCodeProperty);

if (foundProp != null) {

eachPluginStoredProperties.remove(foundProp);

}

eachPlugin.getServerProperties().set(eachPluginCodeProperties);

break;

}

if (foundAction != null)

pluginsConfigs.remove(foundAction);

else

{

List<Property> eachPluginStoredProperties = eachPlugin.getServerProperties().get();

for(Property property :eachPluginStoredProperties)

{

if(property.getType() == Type.STRING || property.getType() == Type.INTEGER || property.getType() == Type.DOUBLE)

property.setRawValue(property.getDefaultRawValue());

}

if (!sortedPlugins.containsKey(eachPlugin.getCategory())) {

ArrayList<NormalAction> actions = new ArrayList<>();

sortedPlugins.put(eachPlugin.getCategory(), actions);

}

sortedPlugins.get(eachPlugin.getCategory()).add(eachPlugin);

/*logger.debug("-----Custom Plugin Debug-----" +

}

"\nAction Type : " + eachPlugin.getActionType() +

catch (Exception e)

"\nName : " + eachPlugin.getName() +

{

"\nFull Module Name : " + eachPlugin.getModuleName() +

"\nAuthor : " + eachPlugin.getAuthor() +

"\nCategory : " + eachPlugin.getCategory() +

"\nRepo : " + eachPlugin.getRepo() +

"\nVersion : " + eachPlugin.getVersion().getText() +

"\n---------------------------");*/

} catch (Exception e) {

e.printStackTrace();

errorModules.add(eachPlugin);

errorModuleError.add(e.getMessage());

}

try {

saveServerSettings();

} catch (MinorException e) {

e.printStackTrace();

}

logger.log(Level.INFO, "All plugins registered!");

if(errorModules.size() > 0)

{

StringBuilder errors = new StringBuilder("The following action modules could not be loaded:");

for(int i = 0; i<errorModules.size(); i++)

{

normalPlugins.remove(errorModules.get(i));

errors.append("\n * ").append(errorModules.get(i).getModuleName()).append("\n(")

.append(errorModuleError.get(i)).append(")");

}

throw new MinorException("Plugins", errors.toString());

}

for(int i = 0;i<normalPlugins.size();i++)

{

normalPluginsHashmap.put(normalPlugins.get(i).getModuleName(), i);

}

/**

* Used to init plugins

public void initPlugins() throws MinorException

{

StringBuilder errors = new StringBuilder("There were errors registering the following plugins. As a result, they have been omitted : ");

boolean isError = false;

for(NormalAction eachPlugin : normalPlugins)

{

try

{

eachPlugin.initAction();

}

catch (Exception e)

{

e.printStackTrace();

isError = true;

errors.append("\n* ")

.append(eachPlugin.getName())

.append(" - ")

.append(eachPlugin.getModuleName())

.append("\n");

if(e instanceof StreamPiException)

errors.append(((MinorException) e).getShortMessage());

errors.append("\n");

}

if(isError)

{

throw new MinorException("Plugin init error", errors.toString());

}

HashMap<String, ArrayList<NormalAction>> sortedPlugins;

/**

* Gets list of sorted plugins

* @return Hashmap with category key, and list of plugins of each category

public HashMap<String, ArrayList<NormalAction>> getSortedPlugins()

{

return sortedPlugins;

}

/**

* @return Gets actions element from the config.xml in plugins folder

private Element getActionsElement()

{

return (Element) document.getElementsByTagName("actions").item(0);

}

/**

* Saves ServerProperties of every plugin in config.xml in plugins folder

* @throws MinorException Thrown when failed to save settings

public void saveServerSettings() throws MinorException

{

XMLConfigHelper.removeChilds(getActionsElement());

for(NormalAction normalAction : normalPlugins)

{

Element actionElement = document.createElement("action");

getActionsElement().appendChild(actionElement);

Element moduleNameElement = document.createElement("module-name");

moduleNameElement.setTextContent(normalAction.getModuleName());

actionElement.appendChild(moduleNameElement);

Element versionElement = document.createElement("version");

versionElement.setTextContent(normalAction.getVersion().getText());

actionElement.appendChild(versionElement);

Element propertiesElement = document.createElement("properties");

actionElement.appendChild(propertiesElement);

for(String key : normalAction.getServerProperties().getNames())

{

for(Property eachProperty : normalAction.getServerProperties().getMultipleProperties(key))

{

Element propertyElement = document.createElement("property");

propertiesElement.appendChild(propertyElement);

Element nameElement = document.createElement("name");

nameElement.setTextContent(eachProperty.getName());

propertyElement.appendChild(nameElement);

Element valueElement = document.createElement("value");

valueElement.setTextContent(eachProperty.getRawValue());

propertyElement.appendChild(valueElement);

}

save();

}

private PropertySaver propertySaver = null;

/**

* Set PropertySaver class

* @param propertySaver instance of PropertySaver

public void setPropertySaver(PropertySaver propertySaver)

{

this.propertySaver = propertySaver;

}

private ServerConnection serverConnection = null;

/**

* Set setServerConnection class

* @param serverConnection instance of ServerConnection

public void setServerConnection(ServerConnection serverConnection)

{

this.serverConnection = serverConnection;

}

/**

* Get plugin from index from list

* @param index of plugin

* @return found plugin

public NormalAction getActionFromIndex(int index)

{

return normalPlugins.get(index);

}

/**

* Calls onShutDown method in every plugin

public void shutDownActions()

{

if(normalPlugins != null)

{

for(NormalAction eachPlugin : normalPlugins)

{

try

{

eachPlugin.onShutDown();

}

catch (Exception e)

{

e.printStackTrace();

}

normalPlugins.clear();

}

/**

* Saves all Server Properties of each Plugin in config.xml in Plugins folder

* @throws MinorException thrown when failed to save

public void save() throws MinorException

{

try

{

Transformer transformer = TransformerFactory.newInstance().newTransformer();

Result output = new StreamResult(configFile);

Source input = new DOMSource(document);

transformer.transform(input, output);

}

catch (Exception e)

{

throw new MinorException("Config", "unable to save server plugins settings");

}

M src/main/java/com/StreamPi/Server/Client/Client.java

+18 −34

Stream-Pi - Free & Open-Source Modular Cross-Platform Programmable Macropad

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 3 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.

Written by : Debayan Sutradhar (rnayabed)

package com.StreamPi.Server.Client;

import com.StreamPi.Server.Connection.ClientConnection;

import com.StreamPi.ThemeAPI.Theme;

import com.StreamPi.Util.Exception.MinorException;

import com.StreamPi.Util.Platform.Platform;

import com.StreamPi.Util.Platform.ReleaseStatus;

import com.StreamPi.Util.Version.Version;

import javafx.geometry.Dimension2D;

import java.net.SocketAddress;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.LinkedList;

import java.util.List;

public class Client {

private String nickName;

private final SocketAddress remoteSocketAddress;

private final Platform platform;

private ClientConnection connectionHandler;

private final Version version;

private final Version commStandardVersion;

private final Version themeAPIVersion;

private final ReleaseStatus releaseStatus;

private double startupDisplayHeight, startupDisplayWidth;

private final HashMap<String,ClientProfile> profiles;

private final HashMap<String,ClientTheme> themes;

private String defaultProfileID;

private String defaultThemeFullName;

private int totalNoOfProfiles;

public Client(Version version, ReleaseStatus releaseStatus, Version commStandardVersion, Version themeAPIVersion, String nickName, Platform platform, SocketAddress remoteSocketAddress)

{

this.version = version;

this.releaseStatus = releaseStatus;

this.commStandardVersion = commStandardVersion;

this.themeAPIVersion = themeAPIVersion;

this.nickName = nickName;

this.remoteSocketAddress = remoteSocketAddress;

this.platform = platform;

this.profiles = new HashMap<>();

this.themes = new HashMap<>();

}

public ReleaseStatus getReleaseStatus() {

return releaseStatus;

}

public void setDefaultThemeFullName(String defaultThemeFullName) {

this.defaultThemeFullName = defaultThemeFullName;

}

public String getDefaultThemeFullName() {

return defaultThemeFullName;

}

public void setTotalNoOfProfiles(int totalNoOfProfiles)

{

this.totalNoOfProfiles = totalNoOfProfiles;

}

public int getTotalNoOfProfiles()

{

return totalNoOfProfiles;

}

public void setDefaultProfileID(String ID)

{

defaultProfileID = ID;

}

public void addTheme(ClientTheme clientTheme) throws CloneNotSupportedException

{

themes.put(clientTheme.getThemeFullName(), (ClientTheme) clientTheme.clone());

}

public ArrayList<ClientTheme> getThemes()

{

ArrayList<ClientTheme> clientThemes = new ArrayList<>();

for(String clientTheme : themes.keySet())

{

clientThemes.add(themes.get(clientTheme));

}

return clientThemes;

}

public ClientTheme getThemeByFullName(String fullName)

{

return themes.getOrDefault(fullName, null);

}

public String getDefaultProfileID()

{

return defaultProfileID;

}

public void setConnectionHandler(ClientConnection connectionHandler)

{

this.connectionHandler = connectionHandler;

}

public ClientConnection getConnectionHandler()

{

return connectionHandler;

}

//Client Profiles

/*public ArrayList<ClientProfile> getProfiles()

{

return profiles;

}*/

public void setNickName(String nickName)

{

this.nickName = nickName;

}

public List<ClientProfile> getAllClientProfiles()

{

ArrayList<ClientProfile> clientProfiles = new ArrayList<>();

for(String profile : profiles.keySet())

clientProfiles.add(profiles.get(profile));

return clientProfiles;

}

public void removeProfileFromID(String ID) throws MinorException {

public void removeProfileFromID(String ID)

{

profiles.remove(ID);

}

public void addProfile(ClientProfile clientProfile) throws CloneNotSupportedException {

profiles.put(clientProfile.getID(), (ClientProfile) clientProfile.clone());

}

public synchronized ClientProfile getProfileByID(String ID) {

return profiles.getOrDefault(ID, null);

}

public SocketAddress getRemoteSocketAddress()

{

return remoteSocketAddress;

}

public Platform getPlatform()

{

return platform;

}

public String getNickName()

{

return nickName;

}

public Version getVersion()

{

return version;

}

public Version getCommStandardVersion()

{

return commStandardVersion;

}

public Version getThemeAPIVersion()

{

return themeAPIVersion;

}

public double getStartupDisplayHeight()

{

return startupDisplayHeight;

}

public double getStartupDisplayWidth()

{

return startupDisplayWidth;

}

public void setStartupDisplayHeight(double height)

{

startupDisplayHeight = height;

}

public void setStartupDisplayWidth(double width)

{

startupDisplayWidth = width;

}

private int getMaxRows(int eachActionSize)

{

return (int) (startupDisplayHeight / eachActionSize);

}

public int getMaxCols(int eachActionSize)

{

return (int) (startupDisplayWidth / eachActionSize);

}

M src/main/java/com/StreamPi/Server/Client/ClientProfile.java

+16 −11

Stream-Pi - Free & Open-Source Modular Cross-Platform Programmable Macropad

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 3 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.

Written by : Debayan Sutradhar (rnayabed)

package com.StreamPi.Server.Client;

import com.StreamPi.ActionAPI.Action.Action;

import com.StreamPi.ActionAPI.Action.ActionType;

import com.StreamPi.ActionAPI.Action.DisplayTextAlignment;

import com.StreamPi.ActionAPI.Action.Location;

import com.StreamPi.ActionAPI.ActionProperty.ClientProperties;

import com.StreamPi.ActionAPI.NormalAction.NormalAction;

import com.StreamPi.Server.Action.NormalActionPlugins;

import com.StreamPi.Server.Window.Dashboard.ActionGridPane.ActionBox;

import com.StreamPi.Util.Exception.MinorException;

import javafx.geometry.Dimension2D;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Set;

import java.util.UUID;

public class ClientProfile implements Cloneable {

private String name, ID;

private int rows, cols, actionSize, actionGap;

private final HashMap<String, Action> actions;

public ClientProfile(String name, String ID, int rows, int cols, int actionSize, int actionGap)

{

this.actions = new HashMap<>();

this.ID = ID;

this.name = name;

this.rows = rows;

this.cols = cols;

this.actionGap = actionGap;

this.actionSize = actionSize;

}

public ClientProfile(String name, int rows, int cols, int actionSize, int actionGap)

{

this(name, UUID.randomUUID().toString(), rows, cols, actionSize, actionGap);

}

public Action getActionByID(String ID)

{

return actions.get(ID);

}

public void removeActionByID(String ID)

{

actions.remove(ID);

}

public Set<String> getActionsKeySet() {

return actions.keySet();

}

public synchronized void addAction(Action action) throws CloneNotSupportedException {

actions.put(action.getID(), action.clone());

}

public String getID()

{

return ID;

}

public String getName()

{

return name;

}

public int getRows()

{

return rows;

}

public int getCols()

{

return cols;

}

public int getActionSize()

{

return actionSize;

}

public int getActionGap()

{

return actionGap;

}

public void setRows(int rows)

{

this.rows = rows;

}

public void setCols(int cols)

{

this.cols = cols;

}

public void setID(String ID)

{

this.ID = ID;

}

public void setActionSize(int actionSize)

{

this.actionSize = actionSize;

}

public void setActionGap(int actionGap)

{

this.actionGap = actionGap;

}

public void setName(String name)

{

this.name = name;

}

public Object clone() throws CloneNotSupportedException

{

return super.clone();

}

M src/main/java/com/StreamPi/Server/Connection/ClientConnection.java

+0 −1

package com.StreamPi.Server.Connection;

import com.StreamPi.ActionAPI.Action.Action;

import com.StreamPi.ActionAPI.Action.ActionType;

import com.StreamPi.ActionAPI.Action.DisplayTextAlignment;

import com.StreamPi.ActionAPI.Action.Location;

import com.StreamPi.ActionAPI.ActionProperty.ClientProperties;

import com.StreamPi.ActionAPI.ActionProperty.Property.Property;

import com.StreamPi.ActionAPI.ActionProperty.Property.Type;

import com.StreamPi.ActionAPI.NormalAction.NormalAction;

import com.StreamPi.ActionAPI.OtherActions.CombineAction;

import com.StreamPi.ActionAPI.OtherActions.FolderAction;

import com.StreamPi.Server.Action.NormalActionPlugins;

import com.StreamPi.Server.Client.Client;

import com.StreamPi.Server.Client.ClientProfile;

import com.StreamPi.Server.Client.ClientTheme;

import com.StreamPi.Server.Info.ServerInfo;

import com.StreamPi.Server.Window.ExceptionAndAlertHandler;

import com.StreamPi.Util.Alert.StreamPiAlert;

import com.StreamPi.Util.Alert.StreamPiAlertType;

import com.StreamPi.Util.Exception.MinorException;

import com.StreamPi.Util.Exception.SevereException;

import com.StreamPi.Util.Exception.StreamPiException;

import com.StreamPi.Util.Platform.Platform;

import com.StreamPi.Util.Platform.ReleaseStatus;

import com.StreamPi.Util.Version.Version;

import javafx.concurrent.Task;

import java.io.ByteArrayOutputStream;

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.IOException;

import java.net.ServerSocket;

import java.net.Socket;

import java.net.SocketException;

import java.net.SocketTimeoutException;

import java.nio.ByteBuffer;

import java.nio.charset.Charset;

import java.nio.charset.StandardCharsets;

import java.util.ArrayList;

import java.util.List;

import java.util.Random;

import java.util.UUID;

import java.util.concurrent.atomic.AtomicBoolean;

import java.util.logging.Level;

import java.util.logging.Logger;

import java.util.stream.Stream;

public class ClientConnection extends Thread{

private Socket socket;

private ServerListener serverListener;

private AtomicBoolean stop = new AtomicBoolean(false);

private DataInputStream dis;

private DataOutputStream dos;

private Logger logger;

private Client client = null;

private ExceptionAndAlertHandler exceptionAndAlertHandler;

public ClientConnection(Socket socket, ServerListener serverListener, ExceptionAndAlertHandler exceptionAndAlertHandler)

{

this.exceptionAndAlertHandler = exceptionAndAlertHandler;

//actionIconsToBeSent = new ArrayList__();

this.socket = socket;

this.serverListener = serverListener;

logger = Logger.getLogger(ClientConnection.class.getName());

try

{

dis = new DataInputStream(socket.getInputStream());

dos = new DataOutputStream(socket.getOutputStream());

} catch (IOException e) {

e.printStackTrace();

exceptionAndAlertHandler.handleMinorException(new MinorException("Unable to start socket streams"));

}

start();

}

public synchronized void exit()

{

if(stop.get())

return;

logger.info("Stopping ...");

try

{

if(socket !=null)

{

logger.info("Stopping connection "+socket.getRemoteSocketAddress());

disconnect();

}

catch (SevereException e)

{

e.printStackTrace();

exceptionAndAlertHandler.handleSevereException(e);

}

public synchronized void exitAndRemove()

{

exit();

removeConnection();

serverListener.clearTemp();

}

public void removeConnection()

{

ClientConnections.getInstance().removeConnection(this);

}

public void writeToStream(String text) throws SevereException

{

/*try

{

logger.debug(text);

dos.writeUTF(text);

dos.flush();

}

catch (IOException e)

{

e.printStackTrace();

throw new SevereException("Unable to write to IO Stream!");

}*/

try

{

byte[] txtBytes = text.getBytes();

Thread.sleep(50);

dos.writeUTF("string:: ::");

dos.flush();

dos.writeInt(txtBytes.length);

dos.flush();

write(txtBytes);

dos.flush();

}

catch (IOException | InterruptedException e)

{

e.printStackTrace();

throw new SevereException("Unable to write to IO Stream!");

}

public void sendIcon(String profileID, String actionID, byte[] icon) throws SevereException

{

try

{

logger.info("Sending action Icon...");

//Thread.sleep(50);

System.out.println("1");

dos.writeUTF("action_icon::"+profileID+"!!"+actionID+"!!::"+icon.length);

System.out.println("2");

dos.flush();

System.out.println("3");

dos.writeInt(icon.length);

System.out.println("4");

dos.flush();

System.out.println("5");

write(icon);

System.out.println("6");

dos.flush();

System.out.println("7");

}

catch (IOException e)

{

e.printStackTrace();

throw new SevereException("Unable to write to IO Stream!");

}

public void write(byte[] array) throws SevereException

{

try

{

dos.write(array);

}

catch (IOException e)

{

e.printStackTrace();

throw new SevereException("Unable to write to IO Stream!");

}

public void initAfterConnectionQueryReceive(String[] arr) throws StreamPiException

{

logger.info("Setting up Client object ...");

Version clientVersion;

Version commsStandard;

Version themesStandard;

ReleaseStatus releaseStatus;

try

{

clientVersion = new Version(arr[1]);

releaseStatus = ReleaseStatus.valueOf(arr[2]);

commsStandard = new Version(arr[3]);

themesStandard = new Version(arr[4]);

}

catch (MinorException e)

{

exitAndRemove();

throw new MinorException(e.getShortMessage()+" (Client '"+socket.getRemoteSocketAddress()+"' )");

}

if(!commsStandard.isEqual(ServerInfo.getInstance().getCommStandardVersion()))

{

String errTxt = "Server and Client Communication standards do not match. Make sure you are on the latest version of server and client.\n" +

"Server Comms. Standard : "+ServerInfo.getInstance().getCommStandardVersion().getText()+

"\nClient Comms. Standard : "+commsStandard.getText();

disconnect(errTxt);

throw new MinorException(errTxt);

}

client = new Client(clientVersion, releaseStatus, commsStandard, themesStandard, arr[5], Platform.valueOf(arr[8]), socket.getRemoteSocketAddress());

client.setStartupDisplayWidth(Double.parseDouble(arr[6]));

client.setStartupDisplayHeight(Double.parseDouble(arr[7]));

client.setDefaultProfileID(arr[9]);

client.setDefaultThemeFullName(arr[10]);

//call get profiles command.

serverListener.clearTemp();

}

public synchronized Client getClient()

{

return client;

}

@Override

public void run() {

try {

initAfterConnectionQuerySend();

} catch (SevereException e) {

e.printStackTrace();

exceptionAndAlertHandler.handleSevereException(e);

exitAndRemove();

return;

}

try

{

while(!stop.get())

{

String msg = "";

try

{

String raw = dis.readUTF();

int length = dis.readInt();

System.out.println("SIZE TO READ : "+length);

String[] precursor = raw.split("::");

String inputType = precursor[0];

String secondArg = precursor[1];

ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

/*int count;

int chunkSize = 512;

while (length>0)

{

if(chunkSize > length)

chunkSize = length;

else

chunkSize = 512;

byte[] buffer = new byte[chunkSize];

count = dis.read(buffer);

System.out.println(count);

byteArrayOutputStream.write(buffer);

length-=count;

}*/

/*byte[] buffer = new byte[8192];

int read;

while((read = dis.read(buffer)) != -1){

System.out.println("READ : "+read);

byteArrayOutputStream.write(buffer, 0, read);

}

System.out.println("READ : "+byteArrayOutputStream.size());

byteArrayOutputStream.close();

byte[] bArr = byteArrayOutputStream.toByteArray();*/

byte[] bArr = new byte[length];

dis.readFully(bArr);

if(inputType.equals("string"))

{

msg = new String(bArr);

}

else if(inputType.equals("action_icon"))

{

String[] secondArgSep = secondArg.split("!!");

String profileID = secondArgSep[0];

String actionID = secondArgSep[1];

getClient().getProfileByID(profileID).getActionByID(actionID).setIcon(bArr);

//serverListener.clearTemp();

continue;

}

catch (IOException e)

{

logger.log(Level.SEVERE, e.getMessage());

e.printStackTrace();

serverListener.clearTemp();

if(!stop.get())

{

removeConnection();

throw new MinorException("Accidentally disconnected from "+getClient().getNickName()+".");

}

exitAndRemove();

return;

}

logger.info("Received text : '"+msg+"'");

String[] sep = msg.split("::");

String command = sep[0];

switch (command)

{

case "disconnect" : clientDisconnected(msg);

break;

case "client_details" : initAfterConnectionQueryReceive(sep);

getProfilesFromClient();

getThemesFromClient();

break;

case "profiles" : registerProfilesFromClient(sep);

break;

case "profile_details" : registerProfileDetailsFromClient(sep);

break;

case "action_details" : registerActionToProfile(sep);

break;

case "themes": registerThemes(sep);

break;

case "action_clicked": actionClicked(sep[1], sep[2]);

break;

default: logger.warning("Command '"+command+"' does not match records. Make sure client and server versions are equal.");

}

catch (StreamPiException e)

{

e.printStackTrace();

if(e instanceof MinorException)

exceptionAndAlertHandler.handleMinorException((MinorException) e);

else if (e instanceof SevereException)

exceptionAndAlertHandler.handleSevereException((SevereException) e);

}

// commands

public void initAfterConnectionQuerySend() throws SevereException

{

logger.info("Asking client details ...");

writeToStream("get_client_details::");

}

public void disconnect() throws SevereException {

disconnect("");

}

public void disconnect(String message) throws SevereException {

if(stop.get())

return;

stop.set(true);

logger.info("Sending client disconnect message ...");

writeToStream("disconnect::"+message+"::");

try

{

if(!socket.isClosed())

socket.close();

}

catch (IOException e)

{

e.printStackTrace();

throw new SevereException("Unable to close socket");

}

public void clientDisconnected(String message)

{

stop.set(true);

String txt = "Disconnected!";

if(!message.equals("disconnect::::"))

txt = "Message : "+message.split("::")[1];

new StreamPiAlert("Disconnected from "+getClient().getNickName()+".", txt, StreamPiAlertType.WARNING).show();;

exitAndRemove();

}

public void getProfilesFromClient() throws StreamPiException

{

logger.info("Asking client to send profiles ...");

writeToStream("get_profiles::");

}

public void getThemesFromClient() throws StreamPiException

{

logger.info("Asking clients to send themes ...");

writeToStream("get_themes::");

}

public void registerThemes(String[] sep)

{

for(int i =1; i<sep.length;i++)

{

String[] internal = sep[i].split("__");

ClientTheme clientTheme = new ClientTheme(

internal[0],

internal[1],

internal[2],

internal[3]

);

try

{

getClient().addTheme(clientTheme);

}

catch (CloneNotSupportedException e)

{

logger.log(Level.SEVERE, e.getMessage());

e.printStackTrace();

}

public void registerProfilesFromClient(String[] sep) throws StreamPiException

{

logger.info("Registering profiles ...");

int noOfProfiles = Integer.parseInt(sep[1]);

getClient().setTotalNoOfProfiles(noOfProfiles);

for(int i = 2; i<(noOfProfiles + 2); i++)

{

String profileID = sep[i];

getProfileDetailsFromClient(profileID);

}

public void getProfileDetailsFromClient(String ID) throws StreamPiException

{

logger.info("Asking client to send details of profile : "+ID);

writeToStream("get_profile_details::"+ID+"::");

}

public void registerProfileDetailsFromClient(String[] sep)

{

String ID = sep[1];

logger.info("Registering details for profile : "+ID);

String name = sep[2];

int rows = Integer.parseInt(sep[3]);

int cols = Integer.parseInt(sep[4]);

int actionSize = Integer.parseInt(sep[5]);

int actionGap = Integer.parseInt(sep[6]);

ClientProfile clientProfile = new ClientProfile(name, ID, rows, cols, actionSize, actionGap);

logger.info("Added client profile "+clientProfile.getName());

try

{

getClient().addProfile(clientProfile);

}

catch (CloneNotSupportedException e)

{

logger.severe(e.getMessage());

e.printStackTrace();

}

serverListener.clearTemp();

}

/*public void getActionIcon(String profileID, String actionID) throws StreamPiException

{

System.out.println("getting action icon from "+profileID+", "+actionID);

writeToStream("get_action_icon::"+profileID+"::"+actionID);

}*/

public synchronized void registerActionToProfile(String[] sep) throws StreamPiException

{

String profileID = sep[1];

String ID = sep[2];

ActionType actionType = ActionType.valueOf(sep[3]);

//4 - Version

//5 - ModuleName

//display

String bgColorHex = sep[6];

//icon

boolean isHasIcon = sep[7].equals("true");

boolean isShowIcon = sep[8].equals("true");

//text

boolean isShowDisplayText = sep[9].equals("true");

String displayFontColor = sep[10];

String displayText = sep[11];

DisplayTextAlignment displayTextAlignment = DisplayTextAlignment.valueOf(sep[12]);

//location

String row = sep[13];

String col = sep[14];

Location location = new Location(Integer.parseInt(row), Integer.parseInt(col));

Action action = new Action(ID, actionType);

action.setBgColourHex(bgColorHex);

action.setShowIcon(isShowIcon);

action.setHasIcon(isHasIcon);

action.setShowDisplayText(isShowDisplayText);

action.setDisplayTextFontColourHex(displayFontColor);

action.setDisplayText(displayText);

action.setDisplayTextAlignment(displayTextAlignment);

action.setLocation(location);

//client properties

int clientPropertiesSize = Integer.parseInt(sep[15]);

String root = sep[17];

action.setParent(root);

String[] clientPropertiesRaw = sep[16].split("!!");

ClientProperties clientProperties = new ClientProperties();

if(actionType == ActionType.FOLDER)

clientProperties.setDuplicatePropertyAllowed(true);

for(int i = 0;i<clientPropertiesSize; i++)

{

String[] clientPraw = clientPropertiesRaw[i].split("__");

Property property = new Property(clientPraw[0], Type.STRING);

if(clientPraw.length > 1)

property.setRawValue(clientPraw[1]);

clientProperties.addProperty(property);

}

action.setClientProperties(clientProperties);

action.setModuleName(sep[5]);

//set up action

//Action toBeAdded = null;

if(actionType == ActionType.NORMAL)

{

NormalAction actionCopy = NormalActionPlugins.getInstance().getPluginByModuleName(sep[5]);

if(actionCopy == null)

{

action.setInvalid(true);

}

else

{

action.setVersion(new Version(sep[4]));

//action.setHelpLink(actionCopy.getHelpLink());

if(actionCopy.getVersion().getMajor() != action.getVersion().getMajor())

{

action.setInvalid(true);

}

else

{

action.setName(actionCopy.getName());

ClientProperties finalClientProperties = new ClientProperties();

for(Property property : actionCopy.getClientProperties().get())

{

for(int i = 0;i<action.getClientProperties().getSize();i++)

{

Property property1 = action.getClientProperties().get().get(i);

if (property.getName().equals(property1.getName()))

{

property.setRawValue(property1.getRawValue());

finalClientProperties.addProperty(property);

}

action.setClientProperties(finalClientProperties);

}

try

{

for(Property prop : action.getClientProperties().get())

{

logger.info("G@@@@@ : "+prop.getRawValue());

}

getClient().getProfileByID(profileID).addAction(action);

for(String action1x : getClient().getProfileByID(profileID).getActionsKeySet())

{

Action action1 = getClient().getProfileByID(profileID).getActionByID(action1x);

logger.info("231cc : "+action1.getID());

for(Property prop : action1.getClientProperties().get())

{

logger.info("G@VVVV@@@ : "+prop.getRawValue());

}

catch (CloneNotSupportedException e)

{

e.printStackTrace();

exceptionAndAlertHandler.handleMinorException(new MinorException("Action", "Unable to clone"));

}

public void saveActionDetails(String profileID, Action action) throws SevereException

{

StringBuilder finalQuery = new StringBuilder("save_action_details::");

//failsafes

if(action.getDisplayText().endsWith(":"))

action.setDisplayText(action.getDisplayText()+" ");

finalQuery.append(profileID)

.append("::")

.append(action.getID())

.append("::")

.append(action.getActionType())

.append("::");

if(action.getActionType() == ActionType.NORMAL)

{

finalQuery.append(action.getVersion().getText());

System.out.println("VERSION :sdd "+action.getVersion().getText());

}

finalQuery.append("::");

if(action.getActionType() == ActionType.NORMAL)

finalQuery.append(action.getModuleName());

finalQuery.append("::");

//display

finalQuery.append(action.getBgColourHex())

.append("::");

//icon

finalQuery.append(action.isHasIcon())

.append("::")

.append(action.isShowIcon())

.append("::");

//text

finalQuery.append(action.isShowDisplayText())

.append("::")

.append(action.getDisplayTextFontColourHex())

.append("::")

.append(action.getDisplayText())

.append("::")

.append(action.getDisplayTextAlignment())

.append("::");

//location

if(action.getLocation() == null)

finalQuery.append("-1::-1::");

else

finalQuery.append(action.getLocation().getRow())

.append("::")

.append(action.getLocation().getCol())

.append("::");

//client properties

ClientProperties clientProperties = action.getClientProperties();

finalQuery.append(clientProperties.getSize())

.append("::");

for(Property property : clientProperties.get())

{

finalQuery.append(property.getName())

.append("__")

.append(property.getRawValue())

.append("__");

finalQuery.append("!!");

}

finalQuery.append("::")

.append(action.getParent())

.append("::");

writeToStream(finalQuery.toString());

}

public void deleteAction(String profileID, String actionID) throws SevereException

{

writeToStream("delete_action::"+profileID+"::"+actionID);

}

public void saveClientDetails(String clientNickname, String screenWidth, String screenHeight, String defaultProfileID,

String defaultThemeFullName) throws SevereException

{

writeToStream("save_client_details::"+

clientNickname+"::"+

screenWidth+"::"+

screenHeight+"::"+

defaultProfileID+"::"+

defaultThemeFullName+"::");

client.setNickName(clientNickname);

client.setStartupDisplayWidth(Double.parseDouble(screenWidth));

client.setStartupDisplayHeight(Double.parseDouble(screenHeight));

client.setDefaultProfileID(defaultProfileID);

client.setDefaultThemeFullName(defaultThemeFullName);

}

public void saveProfileDetails(ClientProfile clientProfile) throws SevereException, CloneNotSupportedException {

if(client.getProfileByID(clientProfile.getID()) !=null)

{

client.getProfileByID(clientProfile.getID()).setName(clientProfile.getName());

client.getProfileByID(clientProfile.getID()).setRows(clientProfile.getRows());

client.getProfileByID(clientProfile.getID()).setCols(clientProfile.getCols());

client.getProfileByID(clientProfile.getID()).setActionSize(clientProfile.getActionSize());

client.getProfileByID(clientProfile.getID()).setActionGap(clientProfile.getActionGap());

}

else

client.addProfile(clientProfile);

writeToStream("save_client_profile::"+

clientProfile.getID()+"::"+

clientProfile.getName()+"::"+

clientProfile.getRows()+"::"+

clientProfile.getCols()+"::"+

clientProfile.getActionSize()+"::"+

clientProfile.getActionGap()+"::");

}

public void deleteProfile(String ID) throws SevereException

{

writeToStream("delete_profile::"+ID+"::");

}

public void actionClicked(String profileID, String actionID) {

try

{

Action action = client.getProfileByID(profileID).getActionByID(actionID);

if(action.getActionType() == ActionType.NORMAL)

{

NormalAction original = NormalActionPlugins.getInstance().getPluginByModuleName(

action.getModuleName()

);

if(original == null)

{

throw new MinorException(

"The Action isn't installed on the server."

);

}

NormalAction normalAction = original.clone();

normalAction.setLocation(action.getLocation());

normalAction.setDisplayText(action.getDisplayText());

normalAction.setID(actionID);

normalAction.setClientProperties(action.getClientProperties());

new Thread(new Task<Void>() {

@Override

protected Void call()

{

try

{

boolean result = serverListener.onNormalActionClicked(normalAction);

if(!result)

{

sendActionFailed(profileID, actionID);

}

catch (SevereException e)

{

exceptionAndAlertHandler.handleSevereException(e);

}

return null;

}

}).start();

}

} catch (Exception e) {

e.printStackTrace();

exceptionAndAlertHandler.handleMinorException(new MinorException(e.getMessage()));

}

public void sendActionFailed(String profileID, String actionID) throws SevereException {

logger.info("Sending failed status ...");

writeToStream("action_failed::"+

profileID+"::"+

actionID+"::");

}

M src/main/java/com/StreamPi/Server/Main.java

+35 −18

Main.java

Stream-Pi - Free & Open-Source Modular Cross-Platform Programmable Macropad

First class started when the app runs.

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 3 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.

Written by Debayan Sutradhar (@rnayabed)

Written by : Debayan Sutradhar (rnayabed)

package com.StreamPi.Server;

import com.StreamPi.Server.Controller.Controller;

import com.StreamPi.Server.Info.ServerInfo;

import javafx.application.Application;

import javafx.application.HostServices;

import javafx.scene.Scene;

import javafx.scene.image.Image;

import javafx.stage.Stage;

public class Main extends Application {

public void start(Stage stage) {

Controller d = new Controller(); //Starts new dash instance

Scene s = new Scene(d); //Starts new scene instance from dash

/**

stage.setScene(s); //Init Scene

* First method to be called

d.setHostServices(getHostServices());

* This method first parses all the available command line arguments passed.

d.init();

* Then a new instance of Controller is created, and then initialised.

}

public void start(Stage stage) {

public static void main(String[] args)

for(String eachArg : getParameters().getRaw())

{

for(String eachArg : args)

{

String[] r = eachArg.split("=");

if(r[0].equals("-DStreamPi.startupRunnerFileName"))

ServerInfo.getInstance().setRunnerFileName(r[1]);

else if(r[0].equals("-DStreamPi.startupMode"))

ServerInfo.getInstance().setStartMinimised(r[1].equals("min"));

}

Controller d = new Controller();

Scene s = new Scene(d);

stage.setScene(s);

d.setHostServices(getHostServices());

d.init();

}

/**

* This is a fallback. Called in some JVMs.

* This method just sends the command line arguments to JavaFX Application

public static void main(String[] args)

{

launch(args);

}

Public

server

Clone or download

Documentation - 1

Modified Files