com.dslplatform.compiler.client.parameters.DslCompiler Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of dsl-clc Show documentation
Command line client for interaction with DSL Platform compiler (https://dsl-platform.com)
The newest version!
package com.dslplatform.compiler.client.parameters;

import com.dslplatform.compiler.client.*;
import com.dslplatform.compiler.client.json.JSON;
import org.w3c.dom.*;

import java.io.*;
import java.lang.management.ManagementFactory;
import java.net.*;
import java.nio.charset.Charset;
import java.util.*;

public enum DslCompiler implements CompileParameter, ParameterParser {
	INSTANCE;

	@Override
	public String getAlias() {
		return "compiler";
	}

	@Override
	public String getUsage() {
		return "path or IP port";
	}

	private final static Charset UTF_8 = Charset.forName("UTF-8");

	private static final String DSL_COMPILER_SOCKET = "dsl-compiler-socket";

	public static Map compile(
			final Context context,
			final String target,
			final List settings,
			final String namespace,
			final String version,
			final DatabaseInfo dbInfo,
			final List dsls,
			final String library,
			final String configuration) throws ExitException {
		final Map files = new HashMap();
		final List arguments = new ArrayList();
		arguments.add("target=" + target);
		if (namespace != null && namespace.length() > 0) {
			arguments.add("namespace=" + namespace);
		}
		if (version != null && version.length() > 0) {
			arguments.add("version=" + version);
		}
		if (settings != null) {
			for (final String o : settings) {
				arguments.add("settings=" + o);
			}
		}
		if (library != null && library.length() > 0) {
			arguments.add("library=" + library);
		}
		if (configuration != null && configuration.length() > 0) {
			arguments.add("configuration=" + configuration);
		}
		if (dbInfo != null) {
			try {
				preparePreviousDsl(context, dbInfo, arguments);
			} catch (IOException ex) {
				context.error("Unable to save old DSL version for comparison.");
				throw new ExitException();
			}
		}
		for (final File f : dsls) {
			arguments.add("dsl=" + f.getAbsolutePath());
		}
		arguments.add("file-extension");
		context.log("Compiling DSL to " + target + "...");
		final long start = new Date().getTime();
		final Either response = runCompiler(context, arguments);
		if (!response.isSuccess()) {
			context.error(response.whyNot());
			throw new ExitException();
		}
		final long end = new Date().getTime();
		context.show("Creating the source took " + (end - start) / 1000 + " second(s)");

		final Either xml = Utils.readXml(new ByteArrayInputStream(response.get()));
		if (!xml.isSuccess()) {
			context.error(new String(response.get(), UTF_8));
			throw new ExitException();
		}
		final NodeList nodes = xml.get().getDocumentElement().getChildNodes();
		try {
			for (int i = 0; i < nodes.getLength(); i++) {
				final Element item = (Element) nodes.item(i);
				final Node key = item.getElementsByTagName("Key").item(0);
				final Node value = item.getElementsByTagName("Value").item(0);
				files.put(key.getTextContent(), value.getTextContent());
			}
		} catch (final Exception ex) {
			context.error("Invalid xml found");
			context.error(new String(response.get(), UTF_8));
			throw new ExitException();
		}
		context.notify("SOURCES", files);
		return files;
	}

	private static Either runCompiler(Context context, List arguments) throws ExitException {
		final Socket socket = context.load(DSL_COMPILER_SOCKET);
		final File compiler = new File(context.get(INSTANCE));
		arguments.add("path=" + System.getProperty("user.dir"));
		context.notify("DSL", arguments);
		return socket != null
				? runCompilerSocket(context, socket, arguments)
				: runCompilerFile(context, compiler, arguments);
	}

	public static class ParseError {
		public final int line;
		public final int column;
		public final String error;

		ParseError(Map map) {
			this.line = map.containsKey("Line") ? ((Number) map.get("Line")).intValue() : 0;
			this.column = map.containsKey("Column") ? ((Number) map.get("Column")).intValue() : 0;
			this.error = (String) map.get("Error");
		}
	}

	public static class ParseResult {
		public final ParseError error;
		public final List tokens;

		@SuppressWarnings("unchecked")
		ParseResult(Map map) {
			List> tokenMap = (List>) map.get("Tokens");
			this.tokens = new ArrayList(tokenMap != null ? tokenMap.size() : 0);
			if (tokenMap != null) {
				for (Map t : tokenMap) {
					tokens.add(new SyntaxConcept(t));
				}
			}
			Object err = map.get("Error");
			this.error = err != null ? new ParseError((Map) err) : null;
		}
	}

	public enum SyntaxType {
		Keyword,
		Identifier,
		StringQuote,
		Expression,
		Type,
		Navigation,
		RuleStart,
		RuleExtension,
		RuleEnd
	}

	public static class SyntaxConcept {
		public final SyntaxType type;
		public final String value;
		public final String script;
		public final int line;
		public final int column;

		SyntaxConcept(Map map) {
			if (map.containsKey("Type")) {
				Object value = map.get("Type");
				if (value instanceof String) {
					this.type = SyntaxType.valueOf((String) value);
				} else {
					this.type = SyntaxType.values()[((Number) value).intValue()];
				}
			} else {
				this.type = SyntaxType.Keyword;
			}
			this.value = map.containsKey("Value") ? (String) map.get("Value") : "";
			this.script = map.containsKey("Script") ? (String) map.get("Script") : "";
			this.line = map.containsKey("Line") ? ((Number) map.get("Line")).intValue() : 0;
			this.column = map.containsKey("Column") ? ((Number) map.get("Column")).intValue() : 0;
		}
	}

	private static class ByteStream extends ByteArrayOutputStream {
		private final byte[] temp = new byte[8192];

		byte[] getBuffer() {
			return buf;
		}
	}

	private static int readInt(final byte[] buf) {
		int ret = 0;
		for (int i = 0; i < 4; i++) {
			ret <<= 8;
			ret |= (int) buf[i] & 0xFF;
		}
		return ret;
	}

	@SuppressWarnings("unchecked")
	public static class RuleInfo {
		public final String rule;
		public final String grammar;
		public final String[] children;
		public final String description;

		RuleInfo(Map json) {
			this.rule = (String) json.get("Rule");
			String gr = (String) json.get("Grammar");
			ArrayList ch = (ArrayList) json.get("Children");
			String de = (String) json.get("Description");
			this.grammar = gr != null ? gr : "";
			this.children = ch != null ? ch.toArray(new String[0]) : new String[0];
			this.description = de != null ? de : "";
		}
	}

	public static class TokenParser implements Closeable {
		private final Context context;
		private final File compiler;
		private final Map rules = new HashMap();

		private int port;
		private Socket socket;
		private Process process;
		private long startedOn;

		public int getPort() {
			return port;
		}

		TokenParser(final Context context, final File compiler, final int port, final Process process) {
			this.context = context;
			this.compiler = compiler;
			setupMonitor(port, process, this);
		}

		public Either findRule(String name) {
			if (name != null) {
				if (rules.isEmpty()) {
					try {
						Socket sck = setupSocket();
						if (sck == null) {
							return Either.fail("Unable to setup socket.");
						}
						Either> newRules = loadRules(sck);
						if (!newRules.isSuccess()) {
							return Either.fail(newRules.whyNot());
						}
						for (RuleInfo ri : newRules.get()) {
							rules.put(ri.rule, ri);
						}
					} catch (Exception ex) {
						return Either.fail("Unable to load rules: " + ex.getMessage());
					}
				}
				RuleInfo rule = rules.get(name);
				if (rule != null) return Either.success(rule);
				else Either.fail("Unknown rule: " + name);
			}
			return Either.fail("Rule name can't be null");
		}

		private void setupMonitor(final int port, final Process process, final TokenParser parser) {
			parser.port = port;
			parser.process = process;
			context.show("Started DSL Platform compiler at port: " + port);
			final Thread waitExit = new Thread(new Runnable() {
				@Override
				public void run() {
					try {
						process.waitFor();
					} catch (Exception ignore) {
					}
					context.show("DSL Platform compiler process stopped");
					parser.process = null;
				}
			});
			waitExit.setDaemon(true);
			waitExit.start();
			final Thread consumeOutput = new Thread(new Runnable() {
				@Override
				public void run() {
					final BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
					final char[] buffer = new char[8192];
					int len;
					try {
						while ((len = reader.read(buffer)) != -1) {
							context.log(new String(buffer, 0, len));
						}
						reader.close();
					} catch (IOException ignore) {
					}
				}
			});
			consumeOutput.setDaemon(true);
			consumeOutput.start();
			startedOn = (new Date()).getTime();
		}

		public Either parse(String dsl) {
			try {
				if (process == null) {
					final Random rnd = new Random();
					final int port = rnd.nextInt(40000) + 20000;
					final Either tryProcess = startServerMode(context, compiler, port);
					if (!tryProcess.isSuccess()) {
						return Either.fail(tryProcess.whyNot());
					}
					setupMonitor(port, tryProcess.get(), this);
					return Either.fail("Server restarting...");
				}
				Either result = parseTokens(setupSocket(), dsl);
				if (!result.isSuccess()) {
					socketCleanup(false);
					result = parseTokens(setupSocket(), dsl);
				}
				if (!result.isSuccess()) {
					socketCleanup(true);
				}
				return result;
			} catch (Exception ex) {
				socketCleanup(true);
				return Either.fail(ex);
			}
		}

		@SuppressWarnings("unchecked")
		private Either> loadRules(final Socket socket) {
			final String command = "format=json rules include-length keep-alive\n";
			try {
				final OutputStream sos = socket.getOutputStream();
				sos.write(command.getBytes(UTF_8));
				sos.flush();
				final ByteStream os = getByteStream(context);
				final byte[] buf = os.temp;
				final InputStream is = socket.getInputStream();
				int read = is.read(buf, 0, 4);
				if (read != 4 || buf[0] != 'O') {
					return Either.fail("Invalid response from server.");
				}
				read = is.read(buf, 0, 4);
				if (read != 4) {
					return Either.fail("Invalid response from server. Expecting length.");
				}
				int length = readInt(buf);
				os.reset();
				while (length > 0 && (read = is.read(buf)) > 0) {
					length -= read;
					os.write(buf, 0, read);
				}
				os.flush();
				final List